# Generated definitions for VTK class group: Filter1
# VTK version: 9.2.6

from ..core import *    
TYPENAMES = []

#--------------------------------------------------------------
class VTK3DLinearGridCrinkleExtractor(Node, BVTK_Node):

    bl_idname = 'VTK3DLinearGridCrinkleExtractorType'
    bl_label  = 'vtk3DLinearGridCrinkleExtractor'
    
    m_CopyCellData: bpy.props.BoolProperty(name='CopyCellData', default=False, update=BVTK_Node.outdate_vtk_status)
    m_CopyPointData: bpy.props.BoolProperty(name='CopyPointData', default=True, update=BVTK_Node.outdate_vtk_status)
    m_RemoveUnusedPoints: bpy.props.BoolProperty(name='RemoveUnusedPoints', default=False, update=BVTK_Node.outdate_vtk_status)
    m_SequentialProcessing: bpy.props.BoolProperty(name='SequentialProcessing', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=5, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_CopyCellData','m_CopyPointData','m_RemoveUnusedPoints','m_SequentialProcessing','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], ['ImplicitFunction'], []) 
    
add_class( VTK3DLinearGridCrinkleExtractor )        
TYPENAMES.append('VTK3DLinearGridCrinkleExtractorType' )

#--------------------------------------------------------------
class VTK3DLinearGridPlaneCutter(Node, BVTK_Node):

    bl_idname = 'VTK3DLinearGridPlaneCutterType'
    bl_label  = 'vtk3DLinearGridPlaneCutter'
    
    m_ComputeNormals: bpy.props.BoolProperty(name='ComputeNormals', default=False, update=BVTK_Node.outdate_vtk_status)
    m_InterpolateAttributes: bpy.props.BoolProperty(name='InterpolateAttributes', default=True, update=BVTK_Node.outdate_vtk_status)
    m_MergePoints: bpy.props.BoolProperty(name='MergePoints', default=False, update=BVTK_Node.outdate_vtk_status)
    m_SequentialProcessing: bpy.props.BoolProperty(name='SequentialProcessing', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=5, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ComputeNormals','m_InterpolateAttributes','m_MergePoints','m_SequentialProcessing','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], ['Plane'], []) 
    
add_class( VTK3DLinearGridPlaneCutter )        
TYPENAMES.append('VTK3DLinearGridPlaneCutterType' )

#--------------------------------------------------------------
class VTKAMRCutPlane(Node, BVTK_Node):

    bl_idname = 'VTKAMRCutPlaneType'
    bl_label  = 'vtkAMRCutPlane'
    
    m_UseNativeCutter: bpy.props.BoolProperty(name='UseNativeCutter', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_LevelOfResolution: bpy.props.IntProperty(name='LevelOfResolution', default=0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=3, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_UseNativeCutter','m_ObjectName','m_LevelOfResolution',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKAMRCutPlane )        
TYPENAMES.append('VTKAMRCutPlaneType' )

#--------------------------------------------------------------
class VTKAMRResampleFilter(Node, BVTK_Node):

    bl_idname = 'VTKAMRResampleFilterType'
    bl_label  = 'vtkAMRResampleFilter'
    
    m_UseBiasVector: bpy.props.BoolProperty(name='UseBiasVector', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DemandDrivenMode: bpy.props.IntProperty(name='DemandDrivenMode', default=0, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfPartitions: bpy.props.IntProperty(name='NumberOfPartitions', default=1, update=BVTK_Node.outdate_vtk_status)
    m_TransferToNodes: bpy.props.IntProperty(name='TransferToNodes', default=1, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfSamples: bpy.props.IntVectorProperty(name='NumberOfSamples', default=[10, 10, 10], size=3, update=BVTK_Node.outdate_vtk_status)
    m_BiasVector: bpy.props.FloatVectorProperty(name='BiasVector', default=[0.0, 0.0, 0.0], size=3, update=BVTK_Node.outdate_vtk_status)
    m_Max: bpy.props.FloatVectorProperty(name='Max', default=[1.0, 1.0, 1.0], size=3, update=BVTK_Node.outdate_vtk_status)
    m_Min: bpy.props.FloatVectorProperty(name='Min', default=[0.0, 0.0, 0.0], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=9, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_UseBiasVector','m_ObjectName','m_DemandDrivenMode','m_NumberOfPartitions','m_TransferToNodes','m_NumberOfSamples','m_BiasVector','m_Max','m_Min',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKAMRResampleFilter )        
TYPENAMES.append('VTKAMRResampleFilterType' )

#--------------------------------------------------------------
class VTKAMRSliceFilter(Node, BVTK_Node):

    bl_idname = 'VTKAMRSliceFilterType'
    bl_label  = 'vtkAMRSliceFilter'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_MaxResolution: bpy.props.IntProperty(name='MaxResolution', default=1, update=BVTK_Node.outdate_vtk_status)
    m_Normal: bpy.props.IntProperty(name='Normal', default=1, update=BVTK_Node.outdate_vtk_status)
    m_OffsetFromOrigin: bpy.props.FloatProperty(name='OffsetFromOrigin', default=0.0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=4, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_MaxResolution','m_Normal','m_OffsetFromOrigin',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKAMRSliceFilter )        
TYPENAMES.append('VTKAMRSliceFilterType' )

#--------------------------------------------------------------
class VTKAMRToMultiBlockFilter(Node, BVTK_Node):

    bl_idname = 'VTKAMRToMultiBlockFilterType'
    bl_label  = 'vtkAMRToMultiBlockFilter'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKAMRToMultiBlockFilter )        
TYPENAMES.append('VTKAMRToMultiBlockFilterType' )

#--------------------------------------------------------------
class VTKAdaptiveDataSetSurfaceFilter(Node, BVTK_Node):

    bl_idname = 'VTKAdaptiveDataSetSurfaceFilterType'
    bl_label  = 'vtkAdaptiveDataSetSurfaceFilter'
    
    m_BBSelection: bpy.props.BoolProperty(name='BBSelection', default=False, update=BVTK_Node.outdate_vtk_status)
    m_CellClipping: bpy.props.BoolProperty(name='CellClipping', default=False, update=BVTK_Node.outdate_vtk_status)
    m_CircleSelection: bpy.props.BoolProperty(name='CircleSelection', default=True, update=BVTK_Node.outdate_vtk_status)
    m_Delegation: bpy.props.BoolProperty(name='Delegation', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ExtentClipping: bpy.props.BoolProperty(name='ExtentClipping', default=False, update=BVTK_Node.outdate_vtk_status)
    m_FastMode: bpy.props.BoolProperty(name='FastMode', default=False, update=BVTK_Node.outdate_vtk_status)
    m_Merging: bpy.props.BoolProperty(name='Merging', default=False, update=BVTK_Node.outdate_vtk_status)
    m_PassThroughCellIds: bpy.props.BoolProperty(name='PassThroughCellIds', default=True, update=BVTK_Node.outdate_vtk_status)
    m_PassThroughPointIds: bpy.props.BoolProperty(name='PassThroughPointIds', default=True, update=BVTK_Node.outdate_vtk_status)
    m_PointClipping: bpy.props.BoolProperty(name='PointClipping', default=False, update=BVTK_Node.outdate_vtk_status)
    m_RemoveGhostInterfaces: bpy.props.BoolProperty(name='RemoveGhostInterfaces', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ViewPointDepend: bpy.props.BoolProperty(name='ViewPointDepend', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_OriginalCellIdsName: bpy.props.StringProperty(name='OriginalCellIdsName', default="vtkOriginalCellIds", update=BVTK_Node.outdate_vtk_status)
    m_OriginalPointIdsName: bpy.props.StringProperty(name='OriginalPointIdsName', default="vtkOriginalPointIds", update=BVTK_Node.outdate_vtk_status)
    m_CellMaximum: bpy.props.IntProperty(name='CellMaximum', default=1000000000, update=BVTK_Node.outdate_vtk_status)
    m_CellMinimum: bpy.props.IntProperty(name='CellMinimum', default=0, update=BVTK_Node.outdate_vtk_status)
    m_Degree: bpy.props.IntProperty(name='Degree', default=4, update=BVTK_Node.outdate_vtk_status)
    m_DynamicDecimateLevelMax: bpy.props.IntProperty(name='DynamicDecimateLevelMax', default=0, update=BVTK_Node.outdate_vtk_status)
    m_FixedLevelMax: bpy.props.IntProperty(name='FixedLevelMax', default=-1, update=BVTK_Node.outdate_vtk_status)
    m_NonlinearSubdivisionLevel: bpy.props.IntProperty(name='NonlinearSubdivisionLevel', default=1, update=BVTK_Node.outdate_vtk_status)
    m_PieceInvariant: bpy.props.IntProperty(name='PieceInvariant', default=0, update=BVTK_Node.outdate_vtk_status)
    m_PointMaximum: bpy.props.IntProperty(name='PointMaximum', default=1000000000, update=BVTK_Node.outdate_vtk_status)
    m_PointMinimum: bpy.props.IntProperty(name='PointMinimum', default=0, update=BVTK_Node.outdate_vtk_status)
    m_Scale: bpy.props.FloatProperty(name='Scale', default=1.0, update=BVTK_Node.outdate_vtk_status)
    m_Extent: bpy.props.FloatVectorProperty(name='Extent', default=[-1e+30, 1e+30, -1e+30, 1e+30, -1e+30, 1e+30], size=6, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=26, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_BBSelection','m_CellClipping','m_CircleSelection','m_Delegation','m_ExtentClipping','m_FastMode','m_Merging','m_PassThroughCellIds','m_PassThroughPointIds','m_PointClipping','m_RemoveGhostInterfaces','m_ViewPointDepend','m_ObjectName','m_OriginalCellIdsName','m_OriginalPointIdsName','m_CellMaximum','m_CellMinimum','m_Degree','m_DynamicDecimateLevelMax','m_FixedLevelMax','m_NonlinearSubdivisionLevel','m_PieceInvariant','m_PointMaximum','m_PointMinimum','m_Scale','m_Extent',]
    def m_connections( self ):
        return (['input'], ['output'], ['Renderer'], []) 
    
add_class( VTKAdaptiveDataSetSurfaceFilter )        
TYPENAMES.append('VTKAdaptiveDataSetSurfaceFilterType' )

#--------------------------------------------------------------
class VTKAdaptiveResampleToImage(Node, BVTK_Node):

    bl_idname = 'VTKAdaptiveResampleToImageType'
    bl_label  = 'vtkAdaptiveResampleToImage'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_NumberOfImages: bpy.props.IntProperty(name='NumberOfImages', default=0, update=BVTK_Node.outdate_vtk_status)
    m_SamplingDimensions: bpy.props.IntVectorProperty(name='SamplingDimensions', default=[64, 64, 64], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=3, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_NumberOfImages','m_SamplingDimensions',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKAdaptiveResampleToImage )        
TYPENAMES.append('VTKAdaptiveResampleToImageType' )

#--------------------------------------------------------------
class VTKAdaptiveSubdivisionFilter(Node, BVTK_Node):

    bl_idname = 'VTKAdaptiveSubdivisionFilterType'
    bl_label  = 'vtkAdaptiveSubdivisionFilter'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_MaximumNumberOfPasses: bpy.props.IntProperty(name='MaximumNumberOfPasses', default=1000000000, update=BVTK_Node.outdate_vtk_status)
    m_MaximumNumberOfTriangles: bpy.props.IntProperty(name='MaximumNumberOfTriangles', default=1000000000, update=BVTK_Node.outdate_vtk_status)
    m_MaximumEdgeLength: bpy.props.FloatProperty(name='MaximumEdgeLength', default=1.0, update=BVTK_Node.outdate_vtk_status)
    m_MaximumTriangleArea: bpy.props.FloatProperty(name='MaximumTriangleArea', default=1.0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=5, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_MaximumNumberOfPasses','m_MaximumNumberOfTriangles','m_MaximumEdgeLength','m_MaximumTriangleArea',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKAdaptiveSubdivisionFilter )        
TYPENAMES.append('VTKAdaptiveSubdivisionFilterType' )

#--------------------------------------------------------------
class VTKAdaptiveTemporalInterpolator(Node, BVTK_Node):

    bl_idname = 'VTKAdaptiveTemporalInterpolatorType'
    bl_label  = 'vtkAdaptiveTemporalInterpolator'
    
    m_CacheData: bpy.props.BoolProperty(name='CacheData', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_ResampleFactor: bpy.props.IntProperty(name='ResampleFactor', default=0, update=BVTK_Node.outdate_vtk_status)
    m_DiscreteTimeStepInterval: bpy.props.FloatProperty(name='DiscreteTimeStepInterval', default=0.0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=4, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_CacheData','m_ObjectName','m_ResampleFactor','m_DiscreteTimeStepInterval',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKAdaptiveTemporalInterpolator )        
TYPENAMES.append('VTKAdaptiveTemporalInterpolatorType' )

#--------------------------------------------------------------
class VTKAggregateDataSetFilter(Node, BVTK_Node):

    bl_idname = 'VTKAggregateDataSetFilterType'
    bl_label  = 'vtkAggregateDataSetFilter'
    
    m_MergePoints: bpy.props.BoolProperty(name='MergePoints', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_NumberOfTargetProcesses: bpy.props.IntProperty(name='NumberOfTargetProcesses', default=1, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=3, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_MergePoints','m_ObjectName','m_NumberOfTargetProcesses',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKAggregateDataSetFilter )        
TYPENAMES.append('VTKAggregateDataSetFilterType' )

#--------------------------------------------------------------
class VTKAlignImageDataSetFilter(Node, BVTK_Node):

    bl_idname = 'VTKAlignImageDataSetFilterType'
    bl_label  = 'vtkAlignImageDataSetFilter'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_MinimumExtent: bpy.props.IntVectorProperty(name='MinimumExtent', default=[0, 0, 0], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_MinimumExtent',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKAlignImageDataSetFilter )        
TYPENAMES.append('VTKAlignImageDataSetFilterType' )

#--------------------------------------------------------------
class VTKAngularPeriodicFilter(Node, BVTK_Node):

    bl_idname = 'VTKAngularPeriodicFilterType'
    bl_label  = 'vtkAngularPeriodicFilter'
    e_IterationMode_items=[ (x,x,x) for x in ['DirectNb', 'Max']]
    e_RotationAxis_items=[ (x,x,x) for x in ['X', 'Y', 'Z']]
    e_RotationMode_items=[ (x,x,x) for x in ['DirectAngle', 'ArrayValue']]
    
    m_ComputeRotationsOnTheFly: bpy.props.BoolProperty(name='ComputeRotationsOnTheFly', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_RotationArrayName: bpy.props.StringProperty(name='RotationArrayName', default="", update=BVTK_Node.outdate_vtk_status)
    m_NumberOfPeriods: bpy.props.IntProperty(name='NumberOfPeriods', default=1, update=BVTK_Node.outdate_vtk_status)
    m_RotationAngle: bpy.props.FloatProperty(name='RotationAngle', default=180.0, update=BVTK_Node.outdate_vtk_status)
    e_IterationMode: bpy.props.EnumProperty(name='IterationMode', default="Max", items=e_IterationMode_items, update=BVTK_Node.outdate_vtk_status)
    e_RotationAxis: bpy.props.EnumProperty(name='RotationAxis', default="X", items=e_RotationAxis_items, update=BVTK_Node.outdate_vtk_status)
    e_RotationMode: bpy.props.EnumProperty(name='RotationMode', default="DirectAngle", items=e_RotationMode_items, update=BVTK_Node.outdate_vtk_status)
    m_Center: bpy.props.FloatVectorProperty(name='Center', default=[0.0, 0.0, 0.0], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=9, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ComputeRotationsOnTheFly','m_ObjectName','m_RotationArrayName','m_NumberOfPeriods','m_RotationAngle','e_IterationMode','e_RotationAxis','e_RotationMode','m_Center',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKAngularPeriodicFilter )        
TYPENAMES.append('VTKAngularPeriodicFilterType' )

#--------------------------------------------------------------
class VTKAnimateModes(Node, BVTK_Node):

    bl_idname = 'VTKAnimateModesType'
    bl_label  = 'vtkAnimateModes'
    
    m_AnimateVibrations: bpy.props.BoolProperty(name='AnimateVibrations', default=True, update=BVTK_Node.outdate_vtk_status)
    m_DisplacementPreapplied: bpy.props.BoolProperty(name='DisplacementPreapplied', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_ModeShape: bpy.props.IntProperty(name='ModeShape', default=1, update=BVTK_Node.outdate_vtk_status)
    m_DisplacementMagnitude: bpy.props.FloatProperty(name='DisplacementMagnitude', default=1.0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=5, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_AnimateVibrations','m_DisplacementPreapplied','m_ObjectName','m_ModeShape','m_DisplacementMagnitude',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKAnimateModes )        
TYPENAMES.append('VTKAnimateModesType' )

#--------------------------------------------------------------
class VTKAnnotationLayersAlgorithm(Node, BVTK_Node):

    bl_idname = 'VTKAnnotationLayersAlgorithmType'
    bl_label  = 'vtkAnnotationLayersAlgorithm'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKAnnotationLayersAlgorithm )        
TYPENAMES.append('VTKAnnotationLayersAlgorithmType' )

#--------------------------------------------------------------
class VTKAppendArcLength(Node, BVTK_Node):

    bl_idname = 'VTKAppendArcLengthType'
    bl_label  = 'vtkAppendArcLength'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKAppendArcLength )        
TYPENAMES.append('VTKAppendArcLengthType' )

#--------------------------------------------------------------
class VTKAppendCompositeDataLeaves(Node, BVTK_Node):

    bl_idname = 'VTKAppendCompositeDataLeavesType'
    bl_label  = 'vtkAppendCompositeDataLeaves'
    
    m_AppendFieldData: bpy.props.BoolProperty(name='AppendFieldData', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_AppendFieldData','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKAppendCompositeDataLeaves )        
TYPENAMES.append('VTKAppendCompositeDataLeavesType' )

#--------------------------------------------------------------
class VTKAppendDataSets(Node, BVTK_Node):

    bl_idname = 'VTKAppendDataSetsType'
    bl_label  = 'vtkAppendDataSets'
    
    m_MergePoints: bpy.props.BoolProperty(name='MergePoints', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ToleranceIsAbsolute: bpy.props.BoolProperty(name='ToleranceIsAbsolute', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_OutputDataSetType: bpy.props.IntProperty(name='OutputDataSetType', default=4, update=BVTK_Node.outdate_vtk_status)
    m_Tolerance: bpy.props.FloatProperty(name='Tolerance', default=0.0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=5, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_MergePoints','m_ToleranceIsAbsolute','m_ObjectName','m_OutputDataSetType','m_Tolerance',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKAppendDataSets )        
TYPENAMES.append('VTKAppendDataSetsType' )

#--------------------------------------------------------------
class VTKAppendFilter(Node, BVTK_Node):

    bl_idname = 'VTKAppendFilterType'
    bl_label  = 'vtkAppendFilter'
    
    m_MergePoints: bpy.props.BoolProperty(name='MergePoints', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ToleranceIsAbsolute: bpy.props.BoolProperty(name='ToleranceIsAbsolute', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_Tolerance: bpy.props.FloatProperty(name='Tolerance', default=0.0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=4, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_MergePoints','m_ToleranceIsAbsolute','m_ObjectName','m_Tolerance',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKAppendFilter )        
TYPENAMES.append('VTKAppendFilterType' )

#--------------------------------------------------------------
class VTKAppendLocationAttributes(Node, BVTK_Node):

    bl_idname = 'VTKAppendLocationAttributesType'
    bl_label  = 'vtkAppendLocationAttributes'
    
    m_AppendCellCenters: bpy.props.BoolProperty(name='AppendCellCenters', default=True, update=BVTK_Node.outdate_vtk_status)
    m_AppendPointLocations: bpy.props.BoolProperty(name='AppendPointLocations', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=3, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_AppendCellCenters','m_AppendPointLocations','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKAppendLocationAttributes )        
TYPENAMES.append('VTKAppendLocationAttributesType' )

#--------------------------------------------------------------
class VTKAppendPoints(Node, BVTK_Node):

    bl_idname = 'VTKAppendPointsType'
    bl_label  = 'vtkAppendPoints'
    
    m_InputIdArrayName: bpy.props.StringProperty(name='InputIdArrayName', default="", update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_InputIdArrayName','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKAppendPoints )        
TYPENAMES.append('VTKAppendPointsType' )

#--------------------------------------------------------------
class VTKAppendPolyData(Node, BVTK_Node):

    bl_idname = 'VTKAppendPolyDataType'
    bl_label  = 'vtkAppendPolyData'
    
    m_ParallelStreaming: bpy.props.BoolProperty(name='ParallelStreaming', default=True, update=BVTK_Node.outdate_vtk_status)
    m_UserManagedInputs: bpy.props.BoolProperty(name='UserManagedInputs', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=3, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ParallelStreaming','m_UserManagedInputs','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKAppendPolyData )        
TYPENAMES.append('VTKAppendPolyDataType' )

#--------------------------------------------------------------
class VTKAppendSelection(Node, BVTK_Node):

    bl_idname = 'VTKAppendSelectionType'
    bl_label  = 'vtkAppendSelection'
    
    m_AppendByUnion: bpy.props.BoolProperty(name='AppendByUnion', default=True, update=BVTK_Node.outdate_vtk_status)
    m_Inverse: bpy.props.BoolProperty(name='Inverse', default=False, update=BVTK_Node.outdate_vtk_status)
    m_UserManagedInputs: bpy.props.BoolProperty(name='UserManagedInputs', default=True, update=BVTK_Node.outdate_vtk_status)
    m_Expression: bpy.props.StringProperty(name='Expression', default="", update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=5, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_AppendByUnion','m_Inverse','m_UserManagedInputs','m_Expression','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKAppendSelection )        
TYPENAMES.append('VTKAppendSelectionType' )

#--------------------------------------------------------------
class VTKArcPlotter(Node, BVTK_Node):

    bl_idname = 'VTKArcPlotterType'
    bl_label  = 'vtkArcPlotter'
    e_PlotMode_items=[ (x,x,x) for x in ['PlotScalars', 'PlotVectors', 'PlotNormals', 'PlotTCoords', 'PlotTensors', 'PlotFieldData']]
    
    m_UseDefaultNormal: bpy.props.BoolProperty(name='UseDefaultNormal', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_FieldDataArray: bpy.props.IntProperty(name='FieldDataArray', default=0, update=BVTK_Node.outdate_vtk_status)
    m_PlotComponent: bpy.props.IntProperty(name='PlotComponent', default=-1, update=BVTK_Node.outdate_vtk_status)
    m_Height: bpy.props.FloatProperty(name='Height', default=0.5, update=BVTK_Node.outdate_vtk_status)
    m_Offset: bpy.props.FloatProperty(name='Offset', default=0.0, update=BVTK_Node.outdate_vtk_status)
    m_Radius: bpy.props.FloatProperty(name='Radius', default=0.5, update=BVTK_Node.outdate_vtk_status)
    e_PlotMode: bpy.props.EnumProperty(name='PlotMode', default="PlotScalars", items=e_PlotMode_items, update=BVTK_Node.outdate_vtk_status)
    m_DefaultNormal: bpy.props.FloatVectorProperty(name='DefaultNormal', default=[0.0, 0.0, 1.0], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=9, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_UseDefaultNormal','m_ObjectName','m_FieldDataArray','m_PlotComponent','m_Height','m_Offset','m_Radius','e_PlotMode','m_DefaultNormal',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKArcPlotter )        
TYPENAMES.append('VTKArcPlotterType' )

#--------------------------------------------------------------
class VTKArrayCalculator(Node, BVTK_Node):

    bl_idname = 'VTKArrayCalculatorType'
    bl_label  = 'vtkArrayCalculator'
    e_AttributeType_items=[ (x,x,x) for x in ['Default', 'PointData', 'CellData', 'VertexData', 'EdgeData', 'RowData']]
    
    m_CoordinateResults: bpy.props.BoolProperty(name='CoordinateResults', default=True, update=BVTK_Node.outdate_vtk_status)
    m_IgnoreMissingArrays: bpy.props.BoolProperty(name='IgnoreMissingArrays', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ReplaceInvalidValues: bpy.props.BoolProperty(name='ReplaceInvalidValues', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ResultNormals: bpy.props.BoolProperty(name='ResultNormals', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ResultTCoords: bpy.props.BoolProperty(name='ResultTCoords', default=False, update=BVTK_Node.outdate_vtk_status)
    m_Function: bpy.props.StringProperty(name='Function', default="", update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_ResultArrayName: bpy.props.StringProperty(name='ResultArrayName', default="resultArray", update=BVTK_Node.outdate_vtk_status)
    m_ResultArrayType: bpy.props.IntProperty(name='ResultArrayType', default=11, update=BVTK_Node.outdate_vtk_status)
    m_ReplacementValue: bpy.props.FloatProperty(name='ReplacementValue', default=0.0, update=BVTK_Node.outdate_vtk_status)
    e_AttributeType: bpy.props.EnumProperty(name='AttributeType', default="Default", items=e_AttributeType_items, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=11, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_CoordinateResults','m_IgnoreMissingArrays','m_ReplaceInvalidValues','m_ResultNormals','m_ResultTCoords','m_Function','m_ObjectName','m_ResultArrayName','m_ResultArrayType','m_ReplacementValue','e_AttributeType',]
    def m_connections( self ):
        return (['input'], ['output'], ['FunctionParserType'], []) 
    
add_class( VTKArrayCalculator )        
TYPENAMES.append('VTKArrayCalculatorType' )

#--------------------------------------------------------------
class VTKArrayDataAlgorithm(Node, BVTK_Node):

    bl_idname = 'VTKArrayDataAlgorithmType'
    bl_label  = 'vtkArrayDataAlgorithm'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKArrayDataAlgorithm )        
TYPENAMES.append('VTKArrayDataAlgorithmType' )

#--------------------------------------------------------------
class VTKArrayRename(Node, BVTK_Node):

    bl_idname = 'VTKArrayRenameType'
    bl_label  = 'vtkArrayRename'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKArrayRename )        
TYPENAMES.append('VTKArrayRenameType' )

#--------------------------------------------------------------
class VTKAssignAttribute(Node, BVTK_Node):

    bl_idname = 'VTKAssignAttributeType'
    bl_label  = 'vtkAssignAttribute'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKAssignAttribute )        
TYPENAMES.append('VTKAssignAttributeType' )

#--------------------------------------------------------------
class VTKAttributeDataToFieldDataFilter(Node, BVTK_Node):

    bl_idname = 'VTKAttributeDataToFieldDataFilterType'
    bl_label  = 'vtkAttributeDataToFieldDataFilter'
    
    m_PassAttributeData: bpy.props.BoolProperty(name='PassAttributeData', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_PassAttributeData','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKAttributeDataToFieldDataFilter )        
TYPENAMES.append('VTKAttributeDataToFieldDataFilterType' )

#--------------------------------------------------------------
class VTKBinnedDecimation(Node, BVTK_Node):

    bl_idname = 'VTKBinnedDecimationType'
    bl_label  = 'vtkBinnedDecimation'
    e_PointGenerationMode_items=[ (x,x,x) for x in ['UseInputPoints', 'BinPoints', 'BinCenters', 'BinAverages']]
    
    m_AutoAdjustNumberOfDivisions: bpy.props.BoolProperty(name='AutoAdjustNumberOfDivisions', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ProduceCellData: bpy.props.BoolProperty(name='ProduceCellData', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ProducePointData: bpy.props.BoolProperty(name='ProducePointData', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_NumberOfXDivisions: bpy.props.IntProperty(name='NumberOfXDivisions', default=256, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfYDivisions: bpy.props.IntProperty(name='NumberOfYDivisions', default=256, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfZDivisions: bpy.props.IntProperty(name='NumberOfZDivisions', default=256, update=BVTK_Node.outdate_vtk_status)
    e_PointGenerationMode: bpy.props.EnumProperty(name='PointGenerationMode', default="BinPoints", items=e_PointGenerationMode_items, update=BVTK_Node.outdate_vtk_status)
    m_DivisionOrigin: bpy.props.FloatVectorProperty(name='DivisionOrigin', default=[0.0, 0.0, 0.0], size=3, update=BVTK_Node.outdate_vtk_status)
    m_DivisionSpacing: bpy.props.FloatVectorProperty(name='DivisionSpacing', default=[1.0, 1.0, 1.0], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=10, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_AutoAdjustNumberOfDivisions','m_ProduceCellData','m_ProducePointData','m_ObjectName','m_NumberOfXDivisions','m_NumberOfYDivisions','m_NumberOfZDivisions','e_PointGenerationMode','m_DivisionOrigin','m_DivisionSpacing',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKBinnedDecimation )        
TYPENAMES.append('VTKBinnedDecimationType' )

#--------------------------------------------------------------
class VTKBlankStructuredGrid(Node, BVTK_Node):

    bl_idname = 'VTKBlankStructuredGridType'
    bl_label  = 'vtkBlankStructuredGrid'
    
    m_ArrayName: bpy.props.StringProperty(name='ArrayName', default="", update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_ArrayId: bpy.props.IntProperty(name='ArrayId', default=-1, update=BVTK_Node.outdate_vtk_status)
    m_Component: bpy.props.IntProperty(name='Component', default=0, update=BVTK_Node.outdate_vtk_status)
    m_MaxBlankingValue: bpy.props.FloatProperty(name='MaxBlankingValue', default=1e+30, update=BVTK_Node.outdate_vtk_status)
    m_MinBlankingValue: bpy.props.FloatProperty(name='MinBlankingValue', default=1e+30, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=6, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ArrayName','m_ObjectName','m_ArrayId','m_Component','m_MaxBlankingValue','m_MinBlankingValue',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKBlankStructuredGrid )        
TYPENAMES.append('VTKBlankStructuredGridType' )

#--------------------------------------------------------------
class VTKBlockIdScalars(Node, BVTK_Node):

    bl_idname = 'VTKBlockIdScalarsType'
    bl_label  = 'vtkBlockIdScalars'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKBlockIdScalars )        
TYPENAMES.append('VTKBlockIdScalarsType' )

#--------------------------------------------------------------
class VTKBrownianPoints(Node, BVTK_Node):

    bl_idname = 'VTKBrownianPointsType'
    bl_label  = 'vtkBrownianPoints'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_MaximumSpeed: bpy.props.FloatProperty(name='MaximumSpeed', default=1.0, update=BVTK_Node.outdate_vtk_status)
    m_MinimumSpeed: bpy.props.FloatProperty(name='MinimumSpeed', default=0.0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=3, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_MaximumSpeed','m_MinimumSpeed',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKBrownianPoints )        
TYPENAMES.append('VTKBrownianPointsType' )

#--------------------------------------------------------------
class VTKButterflySubdivisionFilter(Node, BVTK_Node):

    bl_idname = 'VTKButterflySubdivisionFilterType'
    bl_label  = 'vtkButterflySubdivisionFilter'
    
    m_CheckForTriangles: bpy.props.BoolProperty(name='CheckForTriangles', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_NumberOfSubdivisions: bpy.props.IntProperty(name='NumberOfSubdivisions', default=1, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=3, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_CheckForTriangles','m_ObjectName','m_NumberOfSubdivisions',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKButterflySubdivisionFilter )        
TYPENAMES.append('VTKButterflySubdivisionFilterType' )

#--------------------------------------------------------------
class VTKCastToConcrete(Node, BVTK_Node):

    bl_idname = 'VTKCastToConcreteType'
    bl_label  = 'vtkCastToConcrete'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKCastToConcrete )        
TYPENAMES.append('VTKCastToConcreteType' )

#--------------------------------------------------------------
class VTKCellCenters(Node, BVTK_Node):

    bl_idname = 'VTKCellCentersType'
    bl_label  = 'vtkCellCenters'
    
    m_CopyArrays: bpy.props.BoolProperty(name='CopyArrays', default=True, update=BVTK_Node.outdate_vtk_status)
    m_VertexCells: bpy.props.BoolProperty(name='VertexCells', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=3, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_CopyArrays','m_VertexCells','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKCellCenters )        
TYPENAMES.append('VTKCellCentersType' )

#--------------------------------------------------------------
class VTKCellDataToPointData(Node, BVTK_Node):

    bl_idname = 'VTKCellDataToPointDataType'
    bl_label  = 'vtkCellDataToPointData'
    
    m_PassCellData: bpy.props.BoolProperty(name='PassCellData', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ProcessAllArrays: bpy.props.BoolProperty(name='ProcessAllArrays', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_ContributingCellOption: bpy.props.IntProperty(name='ContributingCellOption', default=0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=4, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_PassCellData','m_ProcessAllArrays','m_ObjectName','m_ContributingCellOption',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKCellDataToPointData )        
TYPENAMES.append('VTKCellDataToPointDataType' )

#--------------------------------------------------------------
class VTKCellDerivatives(Node, BVTK_Node):

    bl_idname = 'VTKCellDerivativesType'
    bl_label  = 'vtkCellDerivatives'
    e_TensorMode_items=[ (x,x,x) for x in ['PassTensors', 'ComputeGradient', 'ComputeStrain', 'ComputeGreenLagrangeStrain']]
    e_VectorMode_items=[ (x,x,x) for x in ['PassVectors', 'ComputeGradient', 'ComputeVorticity']]
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    e_TensorMode: bpy.props.EnumProperty(name='TensorMode', default="ComputeGradient", items=e_TensorMode_items, update=BVTK_Node.outdate_vtk_status)
    e_VectorMode: bpy.props.EnumProperty(name='VectorMode', default="ComputeGradient", items=e_VectorMode_items, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=3, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','e_TensorMode','e_VectorMode',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKCellDerivatives )        
TYPENAMES.append('VTKCellDerivativesType' )

#--------------------------------------------------------------
class VTKCellQuality(Node, BVTK_Node):

    bl_idname = 'VTKCellQualityType'
    bl_label  = 'vtkCellQuality'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_UndefinedQuality: bpy.props.FloatProperty(name='UndefinedQuality', default=-1.0, update=BVTK_Node.outdate_vtk_status)
    m_UnsupportedGeometry: bpy.props.FloatProperty(name='UnsupportedGeometry', default=-1.0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=3, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_UndefinedQuality','m_UnsupportedGeometry',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKCellQuality )        
TYPENAMES.append('VTKCellQualityType' )

#--------------------------------------------------------------
class VTKCellSizeFilter(Node, BVTK_Node):

    bl_idname = 'VTKCellSizeFilterType'
    bl_label  = 'vtkCellSizeFilter'
    
    m_ComputeArea: bpy.props.BoolProperty(name='ComputeArea', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ComputeLength: bpy.props.BoolProperty(name='ComputeLength', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ComputeSum: bpy.props.BoolProperty(name='ComputeSum', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ComputeVertexCount: bpy.props.BoolProperty(name='ComputeVertexCount', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ComputeVolume: bpy.props.BoolProperty(name='ComputeVolume', default=True, update=BVTK_Node.outdate_vtk_status)
    m_AreaArrayName: bpy.props.StringProperty(name='AreaArrayName', default="Area", update=BVTK_Node.outdate_vtk_status)
    m_LengthArrayName: bpy.props.StringProperty(name='LengthArrayName', default="Length", update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_VertexCountArrayName: bpy.props.StringProperty(name='VertexCountArrayName', default="VertexCount", update=BVTK_Node.outdate_vtk_status)
    m_VolumeArrayName: bpy.props.StringProperty(name='VolumeArrayName', default="Volume", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=10, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ComputeArea','m_ComputeLength','m_ComputeSum','m_ComputeVertexCount','m_ComputeVolume','m_AreaArrayName','m_LengthArrayName','m_ObjectName','m_VertexCountArrayName','m_VolumeArrayName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKCellSizeFilter )        
TYPENAMES.append('VTKCellSizeFilterType' )

#--------------------------------------------------------------
class VTKCellValidator(Node, BVTK_Node):

    bl_idname = 'VTKCellValidatorType'
    bl_label  = 'vtkCellValidator'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_Tolerance: bpy.props.FloatProperty(name='Tolerance', default=1.1920928955078125e-07, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_Tolerance',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKCellValidator )        
TYPENAMES.append('VTKCellValidatorType' )

#--------------------------------------------------------------
class VTKCheckerboardSplatter(Node, BVTK_Node):

    bl_idname = 'VTKCheckerboardSplatterType'
    bl_label  = 'vtkCheckerboardSplatter'
    e_AccumulationMode_items=[ (x,x,x) for x in ['Min', 'Max', 'Sum']]
    e_OutputScalarType_items=[ (x,x,x) for x in ['Float', 'Double']]
    
    m_Capping: bpy.props.BoolProperty(name='Capping', default=True, update=BVTK_Node.outdate_vtk_status)
    m_NormalWarping: bpy.props.BoolProperty(name='NormalWarping', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ScalarWarping: bpy.props.BoolProperty(name='ScalarWarping', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_Footprint: bpy.props.IntProperty(name='Footprint', default=2, update=BVTK_Node.outdate_vtk_status)
    m_MaximumDimension: bpy.props.IntProperty(name='MaximumDimension', default=50, update=BVTK_Node.outdate_vtk_status)
    m_ParallelSplatCrossover: bpy.props.IntProperty(name='ParallelSplatCrossover', default=2, update=BVTK_Node.outdate_vtk_status)
    m_CapValue: bpy.props.FloatProperty(name='CapValue', default=0.0, update=BVTK_Node.outdate_vtk_status)
    m_Eccentricity: bpy.props.FloatProperty(name='Eccentricity', default=2.5, update=BVTK_Node.outdate_vtk_status)
    m_ExponentFactor: bpy.props.FloatProperty(name='ExponentFactor', default=-5.0, update=BVTK_Node.outdate_vtk_status)
    m_NullValue: bpy.props.FloatProperty(name='NullValue', default=0.0, update=BVTK_Node.outdate_vtk_status)
    m_Radius: bpy.props.FloatProperty(name='Radius', default=0.0, update=BVTK_Node.outdate_vtk_status)
    m_ScaleFactor: bpy.props.FloatProperty(name='ScaleFactor', default=1.0, update=BVTK_Node.outdate_vtk_status)
    e_AccumulationMode: bpy.props.EnumProperty(name='AccumulationMode', default="Max", items=e_AccumulationMode_items, update=BVTK_Node.outdate_vtk_status)
    e_OutputScalarType: bpy.props.EnumProperty(name='OutputScalarType', default="Float", items=e_OutputScalarType_items, update=BVTK_Node.outdate_vtk_status)
    m_SampleDimensions: bpy.props.IntVectorProperty(name='SampleDimensions', default=[50, 50, 50], size=3, update=BVTK_Node.outdate_vtk_status)
    m_ModelBounds: bpy.props.FloatVectorProperty(name='ModelBounds', default=[0.0, 0.0, 0.0, 0.0, 0.0, 0.0], size=6, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=17, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_Capping','m_NormalWarping','m_ScalarWarping','m_ObjectName','m_Footprint','m_MaximumDimension','m_ParallelSplatCrossover','m_CapValue','m_Eccentricity','m_ExponentFactor','m_NullValue','m_Radius','m_ScaleFactor','e_AccumulationMode','e_OutputScalarType','m_SampleDimensions','m_ModelBounds',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKCheckerboardSplatter )        
TYPENAMES.append('VTKCheckerboardSplatterType' )

#--------------------------------------------------------------
class VTKCleanPolyData(Node, BVTK_Node):

    bl_idname = 'VTKCleanPolyDataType'
    bl_label  = 'vtkCleanPolyData'
    
    m_ConvertLinesToPoints: bpy.props.BoolProperty(name='ConvertLinesToPoints', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ConvertPolysToLines: bpy.props.BoolProperty(name='ConvertPolysToLines', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ConvertStripsToPolys: bpy.props.BoolProperty(name='ConvertStripsToPolys', default=True, update=BVTK_Node.outdate_vtk_status)
    m_PieceInvariant: bpy.props.BoolProperty(name='PieceInvariant', default=True, update=BVTK_Node.outdate_vtk_status)
    m_PointMerging: bpy.props.BoolProperty(name='PointMerging', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ToleranceIsAbsolute: bpy.props.BoolProperty(name='ToleranceIsAbsolute', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_AbsoluteTolerance: bpy.props.FloatProperty(name='AbsoluteTolerance', default=1.0, update=BVTK_Node.outdate_vtk_status)
    m_Tolerance: bpy.props.FloatProperty(name='Tolerance', default=0.0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=9, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ConvertLinesToPoints','m_ConvertPolysToLines','m_ConvertStripsToPolys','m_PieceInvariant','m_PointMerging','m_ToleranceIsAbsolute','m_ObjectName','m_AbsoluteTolerance','m_Tolerance',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKCleanPolyData )        
TYPENAMES.append('VTKCleanPolyDataType' )

#--------------------------------------------------------------
class VTKClipClosedSurface(Node, BVTK_Node):

    bl_idname = 'VTKClipClosedSurfaceType'
    bl_label  = 'vtkClipClosedSurface'
    e_ScalarMode_items=[ (x,x,x) for x in ['None', 'Colors', 'Labels']]
    
    m_GenerateFaces: bpy.props.BoolProperty(name='GenerateFaces', default=True, update=BVTK_Node.outdate_vtk_status)
    m_GenerateOutline: bpy.props.BoolProperty(name='GenerateOutline', default=True, update=BVTK_Node.outdate_vtk_status)
    m_PassPointData: bpy.props.BoolProperty(name='PassPointData', default=True, update=BVTK_Node.outdate_vtk_status)
    m_TriangulationErrorDisplay: bpy.props.BoolProperty(name='TriangulationErrorDisplay', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_ActivePlaneId: bpy.props.IntProperty(name='ActivePlaneId', default=-1, update=BVTK_Node.outdate_vtk_status)
    m_Tolerance: bpy.props.FloatProperty(name='Tolerance', default=1e-06, update=BVTK_Node.outdate_vtk_status)
    e_ScalarMode: bpy.props.EnumProperty(name='ScalarMode', default="None", items=e_ScalarMode_items, update=BVTK_Node.outdate_vtk_status)
    m_ActivePlaneColor: bpy.props.FloatVectorProperty(name='ActivePlaneColor', default=[1.0, 1.0, 0.0], size=3, update=BVTK_Node.outdate_vtk_status)
    m_BaseColor: bpy.props.FloatVectorProperty(name='BaseColor', default=[1.0, 0.0, 0.0], size=3, update=BVTK_Node.outdate_vtk_status)
    m_ClipColor: bpy.props.FloatVectorProperty(name='ClipColor', default=[1.0, 0.5, 0.0], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=11, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_GenerateFaces','m_GenerateOutline','m_PassPointData','m_TriangulationErrorDisplay','m_ObjectName','m_ActivePlaneId','m_Tolerance','e_ScalarMode','m_ActivePlaneColor','m_BaseColor','m_ClipColor',]
    def m_connections( self ):
        return (['input'], ['output'], ['ClippingPlanes'], []) 
    
add_class( VTKClipClosedSurface )        
TYPENAMES.append('VTKClipClosedSurfaceType' )

#--------------------------------------------------------------
class VTKClipConvexPolyData(Node, BVTK_Node):

    bl_idname = 'VTKClipConvexPolyDataType'
    bl_label  = 'vtkClipConvexPolyData'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], ['Planes'], []) 
    
add_class( VTKClipConvexPolyData )        
TYPENAMES.append('VTKClipConvexPolyDataType' )

#--------------------------------------------------------------
class VTKCollectGraph(Node, BVTK_Node):

    bl_idname = 'VTKCollectGraphType'
    bl_label  = 'vtkCollectGraph'
    
    m_PassThrough: bpy.props.BoolProperty(name='PassThrough', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_OutputType: bpy.props.IntProperty(name='OutputType', default=2, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=3, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_PassThrough','m_ObjectName','m_OutputType',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKCollectGraph )        
TYPENAMES.append('VTKCollectGraphType' )

#--------------------------------------------------------------
class VTKCollectPolyData(Node, BVTK_Node):

    bl_idname = 'VTKCollectPolyDataType'
    bl_label  = 'vtkCollectPolyData'
    
    m_PassThrough: bpy.props.BoolProperty(name='PassThrough', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_PassThrough','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKCollectPolyData )        
TYPENAMES.append('VTKCollectPolyDataType' )

#--------------------------------------------------------------
class VTKCollectTable(Node, BVTK_Node):

    bl_idname = 'VTKCollectTableType'
    bl_label  = 'vtkCollectTable'
    
    m_PassThrough: bpy.props.BoolProperty(name='PassThrough', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_PassThrough','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKCollectTable )        
TYPENAMES.append('VTKCollectTableType' )

#--------------------------------------------------------------
class VTKCompositeCutter(Node, BVTK_Node):

    bl_idname = 'VTKCompositeCutterType'
    bl_label  = 'vtkCompositeCutter'
    e_SortBy_items=[ (x,x,x) for x in ['SortByValue', 'SortByCell']]
    
    m_GenerateCutScalars: bpy.props.BoolProperty(name='GenerateCutScalars', default=True, update=BVTK_Node.outdate_vtk_status)
    m_GenerateTriangles: bpy.props.BoolProperty(name='GenerateTriangles', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_NumberOfContours: bpy.props.IntProperty(name='NumberOfContours', default=1, update=BVTK_Node.outdate_vtk_status)
    e_SortBy: bpy.props.EnumProperty(name='SortBy', default="SortByValue", items=e_SortBy_items, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=5, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_GenerateCutScalars','m_GenerateTriangles','m_ObjectName','m_NumberOfContours','e_SortBy',]
    def m_connections( self ):
        return (['input'], ['output'], ['CutFunction'], []) 
    
add_class( VTKCompositeCutter )        
TYPENAMES.append('VTKCompositeCutterType' )

#--------------------------------------------------------------
class VTKCompositeDataGeometryFilter(Node, BVTK_Node):

    bl_idname = 'VTKCompositeDataGeometryFilterType'
    bl_label  = 'vtkCompositeDataGeometryFilter'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKCompositeDataGeometryFilter )        
TYPENAMES.append('VTKCompositeDataGeometryFilterType' )

#--------------------------------------------------------------
class VTKCompositeDataSetAlgorithm(Node, BVTK_Node):

    bl_idname = 'VTKCompositeDataSetAlgorithmType'
    bl_label  = 'vtkCompositeDataSetAlgorithm'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKCompositeDataSetAlgorithm )        
TYPENAMES.append('VTKCompositeDataSetAlgorithmType' )

#--------------------------------------------------------------
class VTKComputeQuantiles(Node, BVTK_Node):

    bl_idname = 'VTKComputeQuantilesType'
    bl_label  = 'vtkComputeQuantiles'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_NumberOfIntervals: bpy.props.IntProperty(name='NumberOfIntervals', default=4, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_NumberOfIntervals',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKComputeQuantiles )        
TYPENAMES.append('VTKComputeQuantilesType' )

#--------------------------------------------------------------
class VTKComputeQuartiles(Node, BVTK_Node):

    bl_idname = 'VTKComputeQuartilesType'
    bl_label  = 'vtkComputeQuartiles'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_NumberOfIntervals: bpy.props.IntProperty(name='NumberOfIntervals', default=4, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_NumberOfIntervals',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKComputeQuartiles )        
TYPENAMES.append('VTKComputeQuartilesType' )

#--------------------------------------------------------------
class VTKConnectedPointsFilter(Node, BVTK_Node):

    bl_idname = 'VTKConnectedPointsFilterType'
    bl_label  = 'vtkConnectedPointsFilter'
    e_ExtractionMode_items=[ (x,x,x) for x in ['PointSeededRegions', 'SpecifiedRegions', 'LargestRegion', 'AllRegions', 'ClosestPointRegion']]
    
    m_AlignedNormals: bpy.props.BoolProperty(name='AlignedNormals', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ScalarConnectivity: bpy.props.BoolProperty(name='ScalarConnectivity', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_NormalAngle: bpy.props.FloatProperty(name='NormalAngle', default=10.0, update=BVTK_Node.outdate_vtk_status)
    m_Radius: bpy.props.FloatProperty(name='Radius', default=1.0, update=BVTK_Node.outdate_vtk_status)
    e_ExtractionMode: bpy.props.EnumProperty(name='ExtractionMode', default="AllRegions", items=e_ExtractionMode_items, update=BVTK_Node.outdate_vtk_status)
    m_ClosestPoint: bpy.props.FloatVectorProperty(name='ClosestPoint', default=[0.0, 0.0, 0.0], size=3, update=BVTK_Node.outdate_vtk_status)
    m_ScalarRange: bpy.props.FloatVectorProperty(name='ScalarRange', default=[0.0, 1.0], size=2, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=8, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_AlignedNormals','m_ScalarConnectivity','m_ObjectName','m_NormalAngle','m_Radius','e_ExtractionMode','m_ClosestPoint','m_ScalarRange',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKConnectedPointsFilter )        
TYPENAMES.append('VTKConnectedPointsFilterType' )

#--------------------------------------------------------------
class VTKConnectivityFilter(Node, BVTK_Node):

    bl_idname = 'VTKConnectivityFilterType'
    bl_label  = 'vtkConnectivityFilter'
    e_ExtractionMode_items=[ (x,x,x) for x in ['PointSeededRegions', 'CellSeededRegions', 'SpecifiedRegions', 'LargestRegion', 'AllRegions', 'ClosestPointRegion']]
    
    m_ColorRegions: bpy.props.BoolProperty(name='ColorRegions', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ScalarConnectivity: bpy.props.BoolProperty(name='ScalarConnectivity', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_RegionIdAssignmentMode: bpy.props.IntProperty(name='RegionIdAssignmentMode', default=0, update=BVTK_Node.outdate_vtk_status)
    e_ExtractionMode: bpy.props.EnumProperty(name='ExtractionMode', default="LargestRegion", items=e_ExtractionMode_items, update=BVTK_Node.outdate_vtk_status)
    m_ClosestPoint: bpy.props.FloatVectorProperty(name='ClosestPoint', default=[0.0, 0.0, 0.0], size=3, update=BVTK_Node.outdate_vtk_status)
    m_ScalarRange: bpy.props.FloatVectorProperty(name='ScalarRange', default=[0.0, 1.0], size=2, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=7, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ColorRegions','m_ScalarConnectivity','m_ObjectName','m_RegionIdAssignmentMode','e_ExtractionMode','m_ClosestPoint','m_ScalarRange',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKConnectivityFilter )        
TYPENAMES.append('VTKConnectivityFilterType' )

#--------------------------------------------------------------
class VTKConstrainedSmoothingFilter(Node, BVTK_Node):

    bl_idname = 'VTKConstrainedSmoothingFilterType'
    bl_label  = 'vtkConstrainedSmoothingFilter'
    e_ConstraintStrategy_items=[ (x,x,x) for x in ['Default', 'ConstraintDistance', 'ConstraintArray']]
    
    m_GenerateErrorScalars: bpy.props.BoolProperty(name='GenerateErrorScalars', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GenerateErrorVectors: bpy.props.BoolProperty(name='GenerateErrorVectors', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_NumberOfIterations: bpy.props.IntProperty(name='NumberOfIterations', default=10, update=BVTK_Node.outdate_vtk_status)
    m_ConstraintDistance: bpy.props.FloatProperty(name='ConstraintDistance', default=0.001, update=BVTK_Node.outdate_vtk_status)
    m_Convergence: bpy.props.FloatProperty(name='Convergence', default=0.0, update=BVTK_Node.outdate_vtk_status)
    m_RelaxationFactor: bpy.props.FloatProperty(name='RelaxationFactor', default=0.01, update=BVTK_Node.outdate_vtk_status)
    e_ConstraintStrategy: bpy.props.EnumProperty(name='ConstraintStrategy', default="Default", items=e_ConstraintStrategy_items, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=8, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_GenerateErrorScalars','m_GenerateErrorVectors','m_ObjectName','m_NumberOfIterations','m_ConstraintDistance','m_Convergence','m_RelaxationFactor','e_ConstraintStrategy',]
    def m_connections( self ):
        return (['input'], ['output'], ['SmoothingStencils'], []) 
    
add_class( VTKConstrainedSmoothingFilter )        
TYPENAMES.append('VTKConstrainedSmoothingFilterType' )

#--------------------------------------------------------------
class VTKContour3DLinearGrid(Node, BVTK_Node):

    bl_idname = 'VTKContour3DLinearGridType'
    bl_label  = 'vtkContour3DLinearGrid'
    
    m_ComputeNormals: bpy.props.BoolProperty(name='ComputeNormals', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ComputeScalars: bpy.props.BoolProperty(name='ComputeScalars', default=True, update=BVTK_Node.outdate_vtk_status)
    m_InterpolateAttributes: bpy.props.BoolProperty(name='InterpolateAttributes', default=True, update=BVTK_Node.outdate_vtk_status)
    m_MergePoints: bpy.props.BoolProperty(name='MergePoints', default=True, update=BVTK_Node.outdate_vtk_status)
    m_SequentialProcessing: bpy.props.BoolProperty(name='SequentialProcessing', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_NumberOfContours: bpy.props.IntProperty(name='NumberOfContours', default=1, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=7, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ComputeNormals','m_ComputeScalars','m_InterpolateAttributes','m_MergePoints','m_SequentialProcessing','m_ObjectName','m_NumberOfContours',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKContour3DLinearGrid )        
TYPENAMES.append('VTKContour3DLinearGridType' )

#--------------------------------------------------------------
class VTKContourFilter(Node, BVTK_Node):

    bl_idname = 'VTKContourFilterType'
    bl_label  = 'vtkContourFilter'
    
    m_ComputeGradients: bpy.props.BoolProperty(name='ComputeGradients', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ComputeNormals: bpy.props.BoolProperty(name='ComputeNormals', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ComputeScalars: bpy.props.BoolProperty(name='ComputeScalars', default=True, update=BVTK_Node.outdate_vtk_status)
    m_GenerateTriangles: bpy.props.BoolProperty(name='GenerateTriangles', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_ArrayComponent: bpy.props.IntProperty(name='ArrayComponent', default=0, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfContours: bpy.props.IntProperty(name='NumberOfContours', default=1, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=7, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ComputeGradients','m_ComputeNormals','m_ComputeScalars','m_GenerateTriangles','m_ObjectName','m_ArrayComponent','m_NumberOfContours',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKContourFilter )        
TYPENAMES.append('VTKContourFilterType' )

#--------------------------------------------------------------
class VTKContourGrid(Node, BVTK_Node):

    bl_idname = 'VTKContourGridType'
    bl_label  = 'vtkContourGrid'
    
    m_ComputeNormals: bpy.props.BoolProperty(name='ComputeNormals', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ComputeScalars: bpy.props.BoolProperty(name='ComputeScalars', default=True, update=BVTK_Node.outdate_vtk_status)
    m_GenerateTriangles: bpy.props.BoolProperty(name='GenerateTriangles', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_NumberOfContours: bpy.props.IntProperty(name='NumberOfContours', default=1, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=5, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ComputeNormals','m_ComputeScalars','m_GenerateTriangles','m_ObjectName','m_NumberOfContours',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKContourGrid )        
TYPENAMES.append('VTKContourGridType' )

#--------------------------------------------------------------
class VTKContourLoopExtraction(Node, BVTK_Node):

    bl_idname = 'VTKContourLoopExtractionType'
    bl_label  = 'vtkContourLoopExtraction'
    e_LoopClosure_items=[ (x,x,x) for x in ['Off', 'Boundary', 'All']]
    e_OutputMode_items=[ (x,x,x) for x in ['Polygons', 'Polylines', 'Both']]
    
    m_CleanPoints: bpy.props.BoolProperty(name='CleanPoints', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ScalarThresholding: bpy.props.BoolProperty(name='ScalarThresholding', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    e_LoopClosure: bpy.props.EnumProperty(name='LoopClosure', default="Boundary", items=e_LoopClosure_items, update=BVTK_Node.outdate_vtk_status)
    e_OutputMode: bpy.props.EnumProperty(name='OutputMode', default="Polygons", items=e_OutputMode_items, update=BVTK_Node.outdate_vtk_status)
    m_Normal: bpy.props.FloatVectorProperty(name='Normal', default=[0.0, 0.0, 1.0], size=3, update=BVTK_Node.outdate_vtk_status)
    m_ScalarRange: bpy.props.FloatVectorProperty(name='ScalarRange', default=[0.0, 1.0], size=2, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=7, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_CleanPoints','m_ScalarThresholding','m_ObjectName','e_LoopClosure','e_OutputMode','m_Normal','m_ScalarRange',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKContourLoopExtraction )        
TYPENAMES.append('VTKContourLoopExtractionType' )

#--------------------------------------------------------------
class VTKContourTriangulator(Node, BVTK_Node):

    bl_idname = 'VTKContourTriangulatorType'
    bl_label  = 'vtkContourTriangulator'
    
    m_TriangulationErrorDisplay: bpy.props.BoolProperty(name='TriangulationErrorDisplay', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_TriangulationErrorDisplay','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKContourTriangulator )        
TYPENAMES.append('VTKContourTriangulatorType' )

#--------------------------------------------------------------
class VTKConvertToMultiBlockDataSet(Node, BVTK_Node):

    bl_idname = 'VTKConvertToMultiBlockDataSetType'
    bl_label  = 'vtkConvertToMultiBlockDataSet'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKConvertToMultiBlockDataSet )        
TYPENAMES.append('VTKConvertToMultiBlockDataSetType' )

#--------------------------------------------------------------
class VTKConvertToPartitionedDataSetCollection(Node, BVTK_Node):

    bl_idname = 'VTKConvertToPartitionedDataSetCollectionType'
    bl_label  = 'vtkConvertToPartitionedDataSetCollection'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKConvertToPartitionedDataSetCollection )        
TYPENAMES.append('VTKConvertToPartitionedDataSetCollectionType' )

#--------------------------------------------------------------
class VTKConvertToPointCloud(Node, BVTK_Node):

    bl_idname = 'VTKConvertToPointCloudType'
    bl_label  = 'vtkConvertToPointCloud'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_CellGenerationMode: bpy.props.IntProperty(name='CellGenerationMode', default=1, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_CellGenerationMode',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKConvertToPointCloud )        
TYPENAMES.append('VTKConvertToPointCloudType' )

#--------------------------------------------------------------
class VTKConvertToPolyhedra(Node, BVTK_Node):

    bl_idname = 'VTKConvertToPolyhedraType'
    bl_label  = 'vtkConvertToPolyhedra'
    
    m_OutputAllCells: bpy.props.BoolProperty(name='OutputAllCells', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_OutputAllCells','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKConvertToPolyhedra )        
TYPENAMES.append('VTKConvertToPolyhedraType' )

#--------------------------------------------------------------
class VTKCountFaces(Node, BVTK_Node):

    bl_idname = 'VTKCountFacesType'
    bl_label  = 'vtkCountFaces'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_OutputArrayName: bpy.props.StringProperty(name='OutputArrayName', default="Face Count", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_OutputArrayName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKCountFaces )        
TYPENAMES.append('VTKCountFacesType' )

#--------------------------------------------------------------
class VTKCountVertices(Node, BVTK_Node):

    bl_idname = 'VTKCountVerticesType'
    bl_label  = 'vtkCountVertices'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_OutputArrayName: bpy.props.StringProperty(name='OutputArrayName', default="Vertex Count", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_OutputArrayName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKCountVertices )        
TYPENAMES.append('VTKCountVerticesType' )

#--------------------------------------------------------------
class VTKCurvatures(Node, BVTK_Node):

    bl_idname = 'VTKCurvaturesType'
    bl_label  = 'vtkCurvatures'
    e_CurvatureType_items=[ (x,x,x) for x in ['Gaussian', 'Mean', 'Maximum', 'Minimum']]
    
    m_InvertMeanCurvature: bpy.props.BoolProperty(name='InvertMeanCurvature', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    e_CurvatureType: bpy.props.EnumProperty(name='CurvatureType', default="Gaussian", items=e_CurvatureType_items, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=3, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_InvertMeanCurvature','m_ObjectName','e_CurvatureType',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKCurvatures )        
TYPENAMES.append('VTKCurvaturesType' )

#--------------------------------------------------------------
class VTKCutMaterial(Node, BVTK_Node):

    bl_idname = 'VTKCutMaterialType'
    bl_label  = 'vtkCutMaterial'
    
    m_ArrayName: bpy.props.StringProperty(name='ArrayName', default="", update=BVTK_Node.outdate_vtk_status)
    m_MaterialArrayName: bpy.props.StringProperty(name='MaterialArrayName', default="material", update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_Material: bpy.props.IntProperty(name='Material', default=0, update=BVTK_Node.outdate_vtk_status)
    m_UpVector: bpy.props.FloatVectorProperty(name='UpVector', default=[0.0, 0.0, 1.0], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=5, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ArrayName','m_MaterialArrayName','m_ObjectName','m_Material','m_UpVector',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKCutMaterial )        
TYPENAMES.append('VTKCutMaterialType' )

#--------------------------------------------------------------
class VTKCutter(Node, BVTK_Node):

    bl_idname = 'VTKCutterType'
    bl_label  = 'vtkCutter'
    e_SortBy_items=[ (x,x,x) for x in ['SortByValue', 'SortByCell']]
    
    m_GenerateCutScalars: bpy.props.BoolProperty(name='GenerateCutScalars', default=True, update=BVTK_Node.outdate_vtk_status)
    m_GenerateTriangles: bpy.props.BoolProperty(name='GenerateTriangles', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_NumberOfContours: bpy.props.IntProperty(name='NumberOfContours', default=1, update=BVTK_Node.outdate_vtk_status)
    e_SortBy: bpy.props.EnumProperty(name='SortBy', default="SortByValue", items=e_SortBy_items, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=5, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_GenerateCutScalars','m_GenerateTriangles','m_ObjectName','m_NumberOfContours','e_SortBy',]
    def m_connections( self ):
        return (['input'], ['output'], ['CutFunction'], []) 
    
add_class( VTKCutter )        
TYPENAMES.append('VTKCutterType' )

#--------------------------------------------------------------
class VTKDataObjectAlgorithm(Node, BVTK_Node):

    bl_idname = 'VTKDataObjectAlgorithmType'
    bl_label  = 'vtkDataObjectAlgorithm'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKDataObjectAlgorithm )        
TYPENAMES.append('VTKDataObjectAlgorithmType' )

#--------------------------------------------------------------
class VTKDataObjectToDataSetFilter(Node, BVTK_Node):

    bl_idname = 'VTKDataObjectToDataSetFilterType'
    bl_label  = 'vtkDataObjectToDataSetFilter'
    e_DataSetType_items=[ (x,x,x) for x in ['PolyData', 'StructuredPoints', 'StructuredGrid', 'RectilinearGrid', 'UnstructuredGrid']]
    
    m_DefaultNormalize: bpy.props.BoolProperty(name='DefaultNormalize', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    e_DataSetType: bpy.props.EnumProperty(name='DataSetType', default="PolyData", items=e_DataSetType_items, update=BVTK_Node.outdate_vtk_status)
    m_Dimensions: bpy.props.IntVectorProperty(name='Dimensions', default=[0, 0, 0], size=3, update=BVTK_Node.outdate_vtk_status)
    m_Origin: bpy.props.FloatVectorProperty(name='Origin', default=[0.0, 0.0, 0.0], size=3, update=BVTK_Node.outdate_vtk_status)
    m_Spacing: bpy.props.FloatVectorProperty(name='Spacing', default=[0.0, 0.0, 0.0], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=6, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_DefaultNormalize','m_ObjectName','e_DataSetType','m_Dimensions','m_Origin','m_Spacing',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKDataObjectToDataSetFilter )        
TYPENAMES.append('VTKDataObjectToDataSetFilterType' )

#--------------------------------------------------------------
class VTKDataSetAlgorithm(Node, BVTK_Node):

    bl_idname = 'VTKDataSetAlgorithmType'
    bl_label  = 'vtkDataSetAlgorithm'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKDataSetAlgorithm )        
TYPENAMES.append('VTKDataSetAlgorithmType' )

#--------------------------------------------------------------
class VTKDataSetGradient(Node, BVTK_Node):

    bl_idname = 'VTKDataSetGradientType'
    bl_label  = 'vtkDataSetGradient'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_ResultArrayName: bpy.props.StringProperty(name='ResultArrayName', default="gradient", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_ResultArrayName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKDataSetGradient )        
TYPENAMES.append('VTKDataSetGradientType' )

#--------------------------------------------------------------
class VTKDataSetGradientPrecompute(Node, BVTK_Node):

    bl_idname = 'VTKDataSetGradientPrecomputeType'
    bl_label  = 'vtkDataSetGradientPrecompute'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKDataSetGradientPrecompute )        
TYPENAMES.append('VTKDataSetGradientPrecomputeType' )

#--------------------------------------------------------------
class VTKDataSetRegionSurfaceFilter(Node, BVTK_Node):

    bl_idname = 'VTKDataSetRegionSurfaceFilterType'
    bl_label  = 'vtkDataSetRegionSurfaceFilter'
    
    m_Delegation: bpy.props.BoolProperty(name='Delegation', default=True, update=BVTK_Node.outdate_vtk_status)
    m_FastMode: bpy.props.BoolProperty(name='FastMode', default=False, update=BVTK_Node.outdate_vtk_status)
    m_PassThroughCellIds: bpy.props.BoolProperty(name='PassThroughCellIds', default=True, update=BVTK_Node.outdate_vtk_status)
    m_PassThroughPointIds: bpy.props.BoolProperty(name='PassThroughPointIds', default=True, update=BVTK_Node.outdate_vtk_status)
    m_SingleSided: bpy.props.BoolProperty(name='SingleSided', default=True, update=BVTK_Node.outdate_vtk_status)
    m_UseStrips: bpy.props.BoolProperty(name='UseStrips', default=True, update=BVTK_Node.outdate_vtk_status)
    m_InterfaceIDsName: bpy.props.StringProperty(name='InterfaceIDsName', default="interface_ids", update=BVTK_Node.outdate_vtk_status)
    m_MaterialIDsName: bpy.props.StringProperty(name='MaterialIDsName', default="material_ids", update=BVTK_Node.outdate_vtk_status)
    m_MaterialPIDsName: bpy.props.StringProperty(name='MaterialPIDsName', default="material_ancestors", update=BVTK_Node.outdate_vtk_status)
    m_MaterialPropertiesName: bpy.props.StringProperty(name='MaterialPropertiesName', default="material_properties", update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_OriginalCellIdsName: bpy.props.StringProperty(name='OriginalCellIdsName', default="vtkOriginalCellIds", update=BVTK_Node.outdate_vtk_status)
    m_OriginalPointIdsName: bpy.props.StringProperty(name='OriginalPointIdsName', default="vtkOriginalPointIds", update=BVTK_Node.outdate_vtk_status)
    m_RegionArrayName: bpy.props.StringProperty(name='RegionArrayName', default="material", update=BVTK_Node.outdate_vtk_status)
    m_NonlinearSubdivisionLevel: bpy.props.IntProperty(name='NonlinearSubdivisionLevel', default=1, update=BVTK_Node.outdate_vtk_status)
    m_PieceInvariant: bpy.props.IntProperty(name='PieceInvariant', default=0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=16, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_Delegation','m_FastMode','m_PassThroughCellIds','m_PassThroughPointIds','m_SingleSided','m_UseStrips','m_InterfaceIDsName','m_MaterialIDsName','m_MaterialPIDsName','m_MaterialPropertiesName','m_ObjectName','m_OriginalCellIdsName','m_OriginalPointIdsName','m_RegionArrayName','m_NonlinearSubdivisionLevel','m_PieceInvariant',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKDataSetRegionSurfaceFilter )        
TYPENAMES.append('VTKDataSetRegionSurfaceFilterType' )

#--------------------------------------------------------------
class VTKDataSetSurfaceFilter(Node, BVTK_Node):

    bl_idname = 'VTKDataSetSurfaceFilterType'
    bl_label  = 'vtkDataSetSurfaceFilter'
    
    m_Delegation: bpy.props.BoolProperty(name='Delegation', default=True, update=BVTK_Node.outdate_vtk_status)
    m_FastMode: bpy.props.BoolProperty(name='FastMode', default=False, update=BVTK_Node.outdate_vtk_status)
    m_PassThroughCellIds: bpy.props.BoolProperty(name='PassThroughCellIds', default=True, update=BVTK_Node.outdate_vtk_status)
    m_PassThroughPointIds: bpy.props.BoolProperty(name='PassThroughPointIds', default=True, update=BVTK_Node.outdate_vtk_status)
    m_UseStrips: bpy.props.BoolProperty(name='UseStrips', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_OriginalCellIdsName: bpy.props.StringProperty(name='OriginalCellIdsName', default="vtkOriginalCellIds", update=BVTK_Node.outdate_vtk_status)
    m_OriginalPointIdsName: bpy.props.StringProperty(name='OriginalPointIdsName', default="vtkOriginalPointIds", update=BVTK_Node.outdate_vtk_status)
    m_NonlinearSubdivisionLevel: bpy.props.IntProperty(name='NonlinearSubdivisionLevel', default=1, update=BVTK_Node.outdate_vtk_status)
    m_PieceInvariant: bpy.props.IntProperty(name='PieceInvariant', default=0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=10, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_Delegation','m_FastMode','m_PassThroughCellIds','m_PassThroughPointIds','m_UseStrips','m_ObjectName','m_OriginalCellIdsName','m_OriginalPointIdsName','m_NonlinearSubdivisionLevel','m_PieceInvariant',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKDataSetSurfaceFilter )        
TYPENAMES.append('VTKDataSetSurfaceFilterType' )

#--------------------------------------------------------------
class VTKDataSetToDataObjectFilter(Node, BVTK_Node):

    bl_idname = 'VTKDataSetToDataObjectFilterType'
    bl_label  = 'vtkDataSetToDataObjectFilter'
    
    m_CellData: bpy.props.BoolProperty(name='CellData', default=True, update=BVTK_Node.outdate_vtk_status)
    m_FieldData: bpy.props.BoolProperty(name='FieldData', default=True, update=BVTK_Node.outdate_vtk_status)
    m_Geometry: bpy.props.BoolProperty(name='Geometry', default=True, update=BVTK_Node.outdate_vtk_status)
    m_LegacyTopology: bpy.props.BoolProperty(name='LegacyTopology', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ModernTopology: bpy.props.BoolProperty(name='ModernTopology', default=True, update=BVTK_Node.outdate_vtk_status)
    m_PointData: bpy.props.BoolProperty(name='PointData', default=True, update=BVTK_Node.outdate_vtk_status)
    m_Topology: bpy.props.BoolProperty(name='Topology', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=8, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_CellData','m_FieldData','m_Geometry','m_LegacyTopology','m_ModernTopology','m_PointData','m_Topology','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKDataSetToDataObjectFilter )        
TYPENAMES.append('VTKDataSetToDataObjectFilterType' )

#--------------------------------------------------------------
class VTKDataSetTriangleFilter(Node, BVTK_Node):

    bl_idname = 'VTKDataSetTriangleFilterType'
    bl_label  = 'vtkDataSetTriangleFilter'
    
    m_TetrahedraOnly: bpy.props.BoolProperty(name='TetrahedraOnly', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_TetrahedraOnly','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKDataSetTriangleFilter )        
TYPENAMES.append('VTKDataSetTriangleFilterType' )

#--------------------------------------------------------------
class VTKDateToNumeric(Node, BVTK_Node):

    bl_idname = 'VTKDateToNumericType'
    bl_label  = 'vtkDateToNumeric'
    
    m_DateFormat: bpy.props.StringProperty(name='DateFormat', default="", update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_DateFormat','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKDateToNumeric )        
TYPENAMES.append('VTKDateToNumericType' )

#--------------------------------------------------------------
class VTKDecimatePolylineFilter(Node, BVTK_Node):

    bl_idname = 'VTKDecimatePolylineFilterType'
    bl_label  = 'vtkDecimatePolylineFilter'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_MaximumError: bpy.props.FloatProperty(name='MaximumError', default=1e+30, update=BVTK_Node.outdate_vtk_status)
    m_TargetReduction: bpy.props.FloatProperty(name='TargetReduction', default=0.9, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=3, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_MaximumError','m_TargetReduction',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKDecimatePolylineFilter )        
TYPENAMES.append('VTKDecimatePolylineFilterType' )

#--------------------------------------------------------------
class VTKDecimatePro(Node, BVTK_Node):

    bl_idname = 'VTKDecimateProType'
    bl_label  = 'vtkDecimatePro'
    
    m_AccumulateError: bpy.props.BoolProperty(name='AccumulateError', default=True, update=BVTK_Node.outdate_vtk_status)
    m_BoundaryVertexDeletion: bpy.props.BoolProperty(name='BoundaryVertexDeletion', default=True, update=BVTK_Node.outdate_vtk_status)
    m_PreSplitMesh: bpy.props.BoolProperty(name='PreSplitMesh', default=True, update=BVTK_Node.outdate_vtk_status)
    m_PreserveTopology: bpy.props.BoolProperty(name='PreserveTopology', default=True, update=BVTK_Node.outdate_vtk_status)
    m_Splitting: bpy.props.BoolProperty(name='Splitting', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_Degree: bpy.props.IntProperty(name='Degree', default=25, update=BVTK_Node.outdate_vtk_status)
    m_ErrorIsAbsolute: bpy.props.IntProperty(name='ErrorIsAbsolute', default=0, update=BVTK_Node.outdate_vtk_status)
    m_AbsoluteError: bpy.props.FloatProperty(name='AbsoluteError', default=1e+30, update=BVTK_Node.outdate_vtk_status)
    m_FeatureAngle: bpy.props.FloatProperty(name='FeatureAngle', default=15.0, update=BVTK_Node.outdate_vtk_status)
    m_InflectionPointRatio: bpy.props.FloatProperty(name='InflectionPointRatio', default=10.0, update=BVTK_Node.outdate_vtk_status)
    m_MaximumError: bpy.props.FloatProperty(name='MaximumError', default=1e+30, update=BVTK_Node.outdate_vtk_status)
    m_SplitAngle: bpy.props.FloatProperty(name='SplitAngle', default=75.0, update=BVTK_Node.outdate_vtk_status)
    m_TargetReduction: bpy.props.FloatProperty(name='TargetReduction', default=0.9, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=14, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_AccumulateError','m_BoundaryVertexDeletion','m_PreSplitMesh','m_PreserveTopology','m_Splitting','m_ObjectName','m_Degree','m_ErrorIsAbsolute','m_AbsoluteError','m_FeatureAngle','m_InflectionPointRatio','m_MaximumError','m_SplitAngle','m_TargetReduction',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKDecimatePro )        
TYPENAMES.append('VTKDecimateProType' )

#--------------------------------------------------------------
class VTKDeflectNormals(Node, BVTK_Node):

    bl_idname = 'VTKDeflectNormalsType'
    bl_label  = 'vtkDeflectNormals'
    
    m_UseUserNormal: bpy.props.BoolProperty(name='UseUserNormal', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_ScaleFactor: bpy.props.FloatProperty(name='ScaleFactor', default=1.0, update=BVTK_Node.outdate_vtk_status)
    m_UserNormal: bpy.props.FloatVectorProperty(name='UserNormal', default=[0.0, 0.0, 1.0], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=4, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_UseUserNormal','m_ObjectName','m_ScaleFactor','m_UserNormal',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKDeflectNormals )        
TYPENAMES.append('VTKDeflectNormalsType' )

#--------------------------------------------------------------
class VTKDelaunay3D(Node, BVTK_Node):

    bl_idname = 'VTKDelaunay3DType'
    bl_label  = 'vtkDelaunay3D'
    
    m_AlphaLines: bpy.props.BoolProperty(name='AlphaLines', default=True, update=BVTK_Node.outdate_vtk_status)
    m_AlphaTets: bpy.props.BoolProperty(name='AlphaTets', default=True, update=BVTK_Node.outdate_vtk_status)
    m_AlphaTris: bpy.props.BoolProperty(name='AlphaTris', default=True, update=BVTK_Node.outdate_vtk_status)
    m_AlphaVerts: bpy.props.BoolProperty(name='AlphaVerts', default=True, update=BVTK_Node.outdate_vtk_status)
    m_BoundingTriangulation: bpy.props.BoolProperty(name='BoundingTriangulation', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_Alpha: bpy.props.FloatProperty(name='Alpha', default=0.0, update=BVTK_Node.outdate_vtk_status)
    m_Offset: bpy.props.FloatProperty(name='Offset', default=2.5, update=BVTK_Node.outdate_vtk_status)
    m_Tolerance: bpy.props.FloatProperty(name='Tolerance', default=0.001, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=9, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_AlphaLines','m_AlphaTets','m_AlphaTris','m_AlphaVerts','m_BoundingTriangulation','m_ObjectName','m_Alpha','m_Offset','m_Tolerance',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKDelaunay3D )        
TYPENAMES.append('VTKDelaunay3DType' )

#--------------------------------------------------------------
class VTKDensifyPointCloudFilter(Node, BVTK_Node):

    bl_idname = 'VTKDensifyPointCloudFilterType'
    bl_label  = 'vtkDensifyPointCloudFilter'
    e_NeighborhoodType_items=[ (x,x,x) for x in ['Radius', 'NClosest']]
    
    m_InterpolateAttributeData: bpy.props.BoolProperty(name='InterpolateAttributeData', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_MaximumNumberOfIterations: bpy.props.IntProperty(name='MaximumNumberOfIterations', default=3, update=BVTK_Node.outdate_vtk_status)
    m_MaximumNumberOfPoints: bpy.props.IntProperty(name='MaximumNumberOfPoints', default=1000000000, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfClosestPoints: bpy.props.IntProperty(name='NumberOfClosestPoints', default=6, update=BVTK_Node.outdate_vtk_status)
    m_Radius: bpy.props.FloatProperty(name='Radius', default=1.0, update=BVTK_Node.outdate_vtk_status)
    m_TargetDistance: bpy.props.FloatProperty(name='TargetDistance', default=0.5, update=BVTK_Node.outdate_vtk_status)
    e_NeighborhoodType: bpy.props.EnumProperty(name='NeighborhoodType', default="NClosest", items=e_NeighborhoodType_items, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=8, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_InterpolateAttributeData','m_ObjectName','m_MaximumNumberOfIterations','m_MaximumNumberOfPoints','m_NumberOfClosestPoints','m_Radius','m_TargetDistance','e_NeighborhoodType',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKDensifyPointCloudFilter )        
TYPENAMES.append('VTKDensifyPointCloudFilterType' )

#--------------------------------------------------------------
class VTKDensifyPolyData(Node, BVTK_Node):

    bl_idname = 'VTKDensifyPolyDataType'
    bl_label  = 'vtkDensifyPolyData'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_NumberOfSubdivisions: bpy.props.IntProperty(name='NumberOfSubdivisions', default=1, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_NumberOfSubdivisions',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKDensifyPolyData )        
TYPENAMES.append('VTKDensifyPolyDataType' )

#--------------------------------------------------------------
class VTKDepthSortPolyData(Node, BVTK_Node):

    bl_idname = 'VTKDepthSortPolyDataType'
    bl_label  = 'vtkDepthSortPolyData'
    e_DepthSortMode_items=[ (x,x,x) for x in ['FirstPoint', 'BoundsCenter', 'ParametricCenter']]
    e_Direction_items=[ (x,x,x) for x in ['BackToFront', 'FrontToBack', 'SpecifiedVector']]
    
    m_SortScalars: bpy.props.BoolProperty(name='SortScalars', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    e_DepthSortMode: bpy.props.EnumProperty(name='DepthSortMode', default="FirstPoint", items=e_DepthSortMode_items, update=BVTK_Node.outdate_vtk_status)
    e_Direction: bpy.props.EnumProperty(name='Direction', default="BackToFront", items=e_Direction_items, update=BVTK_Node.outdate_vtk_status)
    m_Origin: bpy.props.FloatVectorProperty(name='Origin', default=[0.0, 0.0, 0.0], size=3, update=BVTK_Node.outdate_vtk_status)
    m_Vector: bpy.props.FloatVectorProperty(name='Vector', default=[0.0, 0.0, 0.0], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=6, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_SortScalars','m_ObjectName','e_DepthSortMode','e_Direction','m_Origin','m_Vector',]
    def m_connections( self ):
        return (['input'], ['output'], ['Prop3D'], []) 
    
add_class( VTKDepthSortPolyData )        
TYPENAMES.append('VTKDepthSortPolyDataType' )

#--------------------------------------------------------------
class VTKDijkstraGraphGeodesicPath(Node, BVTK_Node):

    bl_idname = 'VTKDijkstraGraphGeodesicPathType'
    bl_label  = 'vtkDijkstraGraphGeodesicPath'
    
    m_RepelPathFromVertices: bpy.props.BoolProperty(name='RepelPathFromVertices', default=True, update=BVTK_Node.outdate_vtk_status)
    m_StopWhenEndReached: bpy.props.BoolProperty(name='StopWhenEndReached', default=True, update=BVTK_Node.outdate_vtk_status)
    m_UseScalarWeights: bpy.props.BoolProperty(name='UseScalarWeights', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_EndVertex: bpy.props.IntProperty(name='EndVertex', default=0, update=BVTK_Node.outdate_vtk_status)
    m_StartVertex: bpy.props.IntProperty(name='StartVertex', default=0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=6, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_RepelPathFromVertices','m_StopWhenEndReached','m_UseScalarWeights','m_ObjectName','m_EndVertex','m_StartVertex',]
    def m_connections( self ):
        return (['input'], ['output'], ['RepelVertices'], []) 
    
add_class( VTKDijkstraGraphGeodesicPath )        
TYPENAMES.append('VTKDijkstraGraphGeodesicPathType' )

#--------------------------------------------------------------
class VTKDijkstraImageGeodesicPath(Node, BVTK_Node):

    bl_idname = 'VTKDijkstraImageGeodesicPathType'
    bl_label  = 'vtkDijkstraImageGeodesicPath'
    
    m_RepelPathFromVertices: bpy.props.BoolProperty(name='RepelPathFromVertices', default=True, update=BVTK_Node.outdate_vtk_status)
    m_StopWhenEndReached: bpy.props.BoolProperty(name='StopWhenEndReached', default=True, update=BVTK_Node.outdate_vtk_status)
    m_UseScalarWeights: bpy.props.BoolProperty(name='UseScalarWeights', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_EndVertex: bpy.props.IntProperty(name='EndVertex', default=0, update=BVTK_Node.outdate_vtk_status)
    m_StartVertex: bpy.props.IntProperty(name='StartVertex', default=0, update=BVTK_Node.outdate_vtk_status)
    m_CurvatureWeight: bpy.props.FloatProperty(name='CurvatureWeight', default=0.0, update=BVTK_Node.outdate_vtk_status)
    m_EdgeLengthWeight: bpy.props.FloatProperty(name='EdgeLengthWeight', default=0.0, update=BVTK_Node.outdate_vtk_status)
    m_ImageWeight: bpy.props.FloatProperty(name='ImageWeight', default=1.0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=9, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_RepelPathFromVertices','m_StopWhenEndReached','m_UseScalarWeights','m_ObjectName','m_EndVertex','m_StartVertex','m_CurvatureWeight','m_EdgeLengthWeight','m_ImageWeight',]
    def m_connections( self ):
        return (['input'], ['output'], ['RepelVertices'], []) 
    
add_class( VTKDijkstraImageGeodesicPath )        
TYPENAMES.append('VTKDijkstraImageGeodesicPathType' )

#--------------------------------------------------------------
class VTKDirectedGraphAlgorithm(Node, BVTK_Node):

    bl_idname = 'VTKDirectedGraphAlgorithmType'
    bl_label  = 'vtkDirectedGraphAlgorithm'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKDirectedGraphAlgorithm )        
TYPENAMES.append('VTKDirectedGraphAlgorithmType' )

#--------------------------------------------------------------
class VTKDiscreteFlyingEdges2D(Node, BVTK_Node):

    bl_idname = 'VTKDiscreteFlyingEdges2DType'
    bl_label  = 'vtkDiscreteFlyingEdges2D'
    
    m_ComputeScalars: bpy.props.BoolProperty(name='ComputeScalars', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_ArrayComponent: bpy.props.IntProperty(name='ArrayComponent', default=0, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfContours: bpy.props.IntProperty(name='NumberOfContours', default=1, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=4, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ComputeScalars','m_ObjectName','m_ArrayComponent','m_NumberOfContours',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKDiscreteFlyingEdges2D )        
TYPENAMES.append('VTKDiscreteFlyingEdges2DType' )

#--------------------------------------------------------------
class VTKDiscreteFlyingEdges3D(Node, BVTK_Node):

    bl_idname = 'VTKDiscreteFlyingEdges3DType'
    bl_label  = 'vtkDiscreteFlyingEdges3D'
    
    m_ComputeGradients: bpy.props.BoolProperty(name='ComputeGradients', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ComputeNormals: bpy.props.BoolProperty(name='ComputeNormals', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ComputeScalars: bpy.props.BoolProperty(name='ComputeScalars', default=True, update=BVTK_Node.outdate_vtk_status)
    m_InterpolateAttributes: bpy.props.BoolProperty(name='InterpolateAttributes', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_ArrayComponent: bpy.props.IntProperty(name='ArrayComponent', default=0, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfContours: bpy.props.IntProperty(name='NumberOfContours', default=1, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=7, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ComputeGradients','m_ComputeNormals','m_ComputeScalars','m_InterpolateAttributes','m_ObjectName','m_ArrayComponent','m_NumberOfContours',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKDiscreteFlyingEdges3D )        
TYPENAMES.append('VTKDiscreteFlyingEdges3DType' )

#--------------------------------------------------------------
class VTKDiscreteFlyingEdgesClipper2D(Node, BVTK_Node):

    bl_idname = 'VTKDiscreteFlyingEdgesClipper2DType'
    bl_label  = 'vtkDiscreteFlyingEdgesClipper2D'
    
    m_ComputeScalars: bpy.props.BoolProperty(name='ComputeScalars', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_ArrayComponent: bpy.props.IntProperty(name='ArrayComponent', default=0, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfContours: bpy.props.IntProperty(name='NumberOfContours', default=1, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=4, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ComputeScalars','m_ObjectName','m_ArrayComponent','m_NumberOfContours',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKDiscreteFlyingEdgesClipper2D )        
TYPENAMES.append('VTKDiscreteFlyingEdgesClipper2DType' )

#--------------------------------------------------------------
class VTKDiscreteMarchingCubes(Node, BVTK_Node):

    bl_idname = 'VTKDiscreteMarchingCubesType'
    bl_label  = 'vtkDiscreteMarchingCubes'
    
    m_ComputeAdjacentScalars: bpy.props.BoolProperty(name='ComputeAdjacentScalars', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ComputeGradients: bpy.props.BoolProperty(name='ComputeGradients', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ComputeNormals: bpy.props.BoolProperty(name='ComputeNormals', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ComputeScalars: bpy.props.BoolProperty(name='ComputeScalars', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_NumberOfContours: bpy.props.IntProperty(name='NumberOfContours', default=1, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=6, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ComputeAdjacentScalars','m_ComputeGradients','m_ComputeNormals','m_ComputeScalars','m_ObjectName','m_NumberOfContours',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKDiscreteMarchingCubes )        
TYPENAMES.append('VTKDiscreteMarchingCubesType' )

#--------------------------------------------------------------
class VTKDistributedDataFilter(Node, BVTK_Node):

    bl_idname = 'VTKDistributedDataFilterType'
    bl_label  = 'vtkDistributedDataFilter'
    e_BoundaryMode_items=[ (x,x,x) for x in ['AssignToOneRegion', 'AssignToAllIntersectingRegions', 'SplitBoundaryCells']]
    
    m_ClipCells: bpy.props.BoolProperty(name='ClipCells', default=True, update=BVTK_Node.outdate_vtk_status)
    m_IncludeAllIntersectingCells: bpy.props.BoolProperty(name='IncludeAllIntersectingCells', default=True, update=BVTK_Node.outdate_vtk_status)
    m_RetainKdtree: bpy.props.BoolProperty(name='RetainKdtree', default=True, update=BVTK_Node.outdate_vtk_status)
    m_Timing: bpy.props.BoolProperty(name='Timing', default=True, update=BVTK_Node.outdate_vtk_status)
    m_UseMinimalMemory: bpy.props.BoolProperty(name='UseMinimalMemory', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_MinimumGhostLevel: bpy.props.IntProperty(name='MinimumGhostLevel', default=0, update=BVTK_Node.outdate_vtk_status)
    e_BoundaryMode: bpy.props.EnumProperty(name='BoundaryMode', default="AssignToOneRegion", items=e_BoundaryMode_items, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=8, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ClipCells','m_IncludeAllIntersectingCells','m_RetainKdtree','m_Timing','m_UseMinimalMemory','m_ObjectName','m_MinimumGhostLevel','e_BoundaryMode',]
    def m_connections( self ):
        return (['input'], ['output'], ['Cuts'], []) 
    
add_class( VTKDistributedDataFilter )        
TYPENAMES.append('VTKDistributedDataFilterType' )

#--------------------------------------------------------------
class VTKDuplicatePolyData(Node, BVTK_Node):

    bl_idname = 'VTKDuplicatePolyDataType'
    bl_label  = 'vtkDuplicatePolyData'
    
    m_Synchronous: bpy.props.BoolProperty(name='Synchronous', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_ClientFlag: bpy.props.IntProperty(name='ClientFlag', default=0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=3, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_Synchronous','m_ObjectName','m_ClientFlag',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKDuplicatePolyData )        
TYPENAMES.append('VTKDuplicatePolyDataType' )

#--------------------------------------------------------------
class VTKEdgePoints(Node, BVTK_Node):

    bl_idname = 'VTKEdgePointsType'
    bl_label  = 'vtkEdgePoints'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_Value: bpy.props.FloatProperty(name='Value', default=0.0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_Value',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKEdgePoints )        
TYPENAMES.append('VTKEdgePointsType' )

#--------------------------------------------------------------
class VTKElevationFilter(Node, BVTK_Node):

    bl_idname = 'VTKElevationFilterType'
    bl_label  = 'vtkElevationFilter'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_HighPoint: bpy.props.FloatVectorProperty(name='HighPoint', default=[0.0, 0.0, 1.0], size=3, update=BVTK_Node.outdate_vtk_status)
    m_LowPoint: bpy.props.FloatVectorProperty(name='LowPoint', default=[0.0, 0.0, 0.0], size=3, update=BVTK_Node.outdate_vtk_status)
    m_ScalarRange: bpy.props.FloatVectorProperty(name='ScalarRange', default=[0.0, 1.0], size=2, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=4, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_HighPoint','m_LowPoint','m_ScalarRange',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKElevationFilter )        
TYPENAMES.append('VTKElevationFilterType' )

#--------------------------------------------------------------
class VTKEuclideanClusterExtraction(Node, BVTK_Node):

    bl_idname = 'VTKEuclideanClusterExtractionType'
    bl_label  = 'vtkEuclideanClusterExtraction'
    e_ExtractionMode_items=[ (x,x,x) for x in ['PointSeededClusters', 'SpecifiedClusters', 'LargestCluster', 'AllClusters', 'ClosestPointCluster']]
    
    m_ColorClusters: bpy.props.BoolProperty(name='ColorClusters', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ScalarConnectivity: bpy.props.BoolProperty(name='ScalarConnectivity', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_Radius: bpy.props.FloatProperty(name='Radius', default=0.0, update=BVTK_Node.outdate_vtk_status)
    e_ExtractionMode: bpy.props.EnumProperty(name='ExtractionMode', default="LargestCluster", items=e_ExtractionMode_items, update=BVTK_Node.outdate_vtk_status)
    m_ClosestPoint: bpy.props.FloatVectorProperty(name='ClosestPoint', default=[0.0, 0.0, 0.0], size=3, update=BVTK_Node.outdate_vtk_status)
    m_ScalarRange: bpy.props.FloatVectorProperty(name='ScalarRange', default=[0.0, 1.0], size=2, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=7, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ColorClusters','m_ScalarConnectivity','m_ObjectName','m_Radius','e_ExtractionMode','m_ClosestPoint','m_ScalarRange',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKEuclideanClusterExtraction )        
TYPENAMES.append('VTKEuclideanClusterExtractionType' )

#--------------------------------------------------------------
class VTKEvenlySpacedStreamlines2D(Node, BVTK_Node):

    bl_idname = 'VTKEvenlySpacedStreamlines2DType'
    bl_label  = 'vtkEvenlySpacedStreamlines2D'
    e_IntegratorType_items=[ (x,x,x) for x in ['RungeKutta2', 'RungeKutta4']]
    
    m_ComputeVorticity: bpy.props.BoolProperty(name='ComputeVorticity', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_IntegrationStepUnit: bpy.props.IntProperty(name='IntegrationStepUnit', default=2, update=BVTK_Node.outdate_vtk_status)
    m_MaximumNumberOfSteps: bpy.props.IntProperty(name='MaximumNumberOfSteps', default=2000, update=BVTK_Node.outdate_vtk_status)
    m_MinimumNumberOfLoopPoints: bpy.props.IntProperty(name='MinimumNumberOfLoopPoints', default=4, update=BVTK_Node.outdate_vtk_status)
    m_ClosedLoopMaximumDistance: bpy.props.FloatProperty(name='ClosedLoopMaximumDistance', default=1e-06, update=BVTK_Node.outdate_vtk_status)
    m_InitialIntegrationStep: bpy.props.FloatProperty(name='InitialIntegrationStep', default=0.5, update=BVTK_Node.outdate_vtk_status)
    m_LoopAngle: bpy.props.FloatProperty(name='LoopAngle', default=0.349066, update=BVTK_Node.outdate_vtk_status)
    m_SeparatingDistance: bpy.props.FloatProperty(name='SeparatingDistance', default=1.0, update=BVTK_Node.outdate_vtk_status)
    m_SeparatingDistanceRatio: bpy.props.FloatProperty(name='SeparatingDistanceRatio', default=0.5, update=BVTK_Node.outdate_vtk_status)
    m_TerminalSpeed: bpy.props.FloatProperty(name='TerminalSpeed', default=1e-12, update=BVTK_Node.outdate_vtk_status)
    e_IntegratorType: bpy.props.EnumProperty(name='IntegratorType', default="RungeKutta2", items=e_IntegratorType_items, update=BVTK_Node.outdate_vtk_status)
    m_StartPosition: bpy.props.FloatVectorProperty(name='StartPosition', default=[0.0, 0.0, 0.0], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=13, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ComputeVorticity','m_ObjectName','m_IntegrationStepUnit','m_MaximumNumberOfSteps','m_MinimumNumberOfLoopPoints','m_ClosedLoopMaximumDistance','m_InitialIntegrationStep','m_LoopAngle','m_SeparatingDistance','m_SeparatingDistanceRatio','m_TerminalSpeed','e_IntegratorType','m_StartPosition',]
    def m_connections( self ):
        return (['input'], ['output'], ['Integrator'], []) 
    
add_class( VTKEvenlySpacedStreamlines2D )        
TYPENAMES.append('VTKEvenlySpacedStreamlines2DType' )

#--------------------------------------------------------------
class VTKExpandMarkedElements(Node, BVTK_Node):

    bl_idname = 'VTKExpandMarkedElementsType'
    bl_label  = 'vtkExpandMarkedElements'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_NumberOfLayers: bpy.props.IntProperty(name='NumberOfLayers', default=2, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_NumberOfLayers',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKExpandMarkedElements )        
TYPENAMES.append('VTKExpandMarkedElementsType' )

#--------------------------------------------------------------
class VTKExplicitStructuredGridAlgorithm(Node, BVTK_Node):

    bl_idname = 'VTKExplicitStructuredGridAlgorithmType'
    bl_label  = 'vtkExplicitStructuredGridAlgorithm'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKExplicitStructuredGridAlgorithm )        
TYPENAMES.append('VTKExplicitStructuredGridAlgorithmType' )

#--------------------------------------------------------------
class VTKExplicitStructuredGridCrop(Node, BVTK_Node):

    bl_idname = 'VTKExplicitStructuredGridCropType'
    bl_label  = 'vtkExplicitStructuredGridCrop'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKExplicitStructuredGridCrop )        
TYPENAMES.append('VTKExplicitStructuredGridCropType' )

#--------------------------------------------------------------
class VTKExplicitStructuredGridSurfaceFilter(Node, BVTK_Node):

    bl_idname = 'VTKExplicitStructuredGridSurfaceFilterType'
    bl_label  = 'vtkExplicitStructuredGridSurfaceFilter'
    
    m_PassThroughCellIds: bpy.props.BoolProperty(name='PassThroughCellIds', default=True, update=BVTK_Node.outdate_vtk_status)
    m_PassThroughPointIds: bpy.props.BoolProperty(name='PassThroughPointIds', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_OriginalCellIdsName: bpy.props.StringProperty(name='OriginalCellIdsName', default="vtkOriginalCellIds", update=BVTK_Node.outdate_vtk_status)
    m_OriginalPointIdsName: bpy.props.StringProperty(name='OriginalPointIdsName', default="vtkOriginalPointIds", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=5, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_PassThroughCellIds','m_PassThroughPointIds','m_ObjectName','m_OriginalCellIdsName','m_OriginalPointIdsName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKExplicitStructuredGridSurfaceFilter )        
TYPENAMES.append('VTKExplicitStructuredGridSurfaceFilterType' )

#--------------------------------------------------------------
class VTKExplicitStructuredGridToUnstructuredGrid(Node, BVTK_Node):

    bl_idname = 'VTKExplicitStructuredGridToUnstructuredGridType'
    bl_label  = 'vtkExplicitStructuredGridToUnstructuredGrid'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKExplicitStructuredGridToUnstructuredGrid )        
TYPENAMES.append('VTKExplicitStructuredGridToUnstructuredGridType' )

#--------------------------------------------------------------
class VTKExtractArray(Node, BVTK_Node):

    bl_idname = 'VTKExtractArrayType'
    bl_label  = 'vtkExtractArray'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_Index: bpy.props.IntProperty(name='Index', default=0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_Index',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKExtractArray )        
TYPENAMES.append('VTKExtractArrayType' )

#--------------------------------------------------------------
class VTKExtractBlock(Node, BVTK_Node):

    bl_idname = 'VTKExtractBlockType'
    bl_label  = 'vtkExtractBlock'
    
    m_MaintainStructure: bpy.props.BoolProperty(name='MaintainStructure', default=True, update=BVTK_Node.outdate_vtk_status)
    m_PruneOutput: bpy.props.BoolProperty(name='PruneOutput', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=3, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_MaintainStructure','m_PruneOutput','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKExtractBlock )        
TYPENAMES.append('VTKExtractBlockType' )

#--------------------------------------------------------------
class VTKExtractBlockUsingDataAssembly(Node, BVTK_Node):

    bl_idname = 'VTKExtractBlockUsingDataAssemblyType'
    bl_label  = 'vtkExtractBlockUsingDataAssembly'
    
    m_PruneDataAssembly: bpy.props.BoolProperty(name='PruneDataAssembly', default=True, update=BVTK_Node.outdate_vtk_status)
    m_SelectSubtrees: bpy.props.BoolProperty(name='SelectSubtrees', default=True, update=BVTK_Node.outdate_vtk_status)
    m_AssemblyName: bpy.props.StringProperty(name='AssemblyName', default="Hierarchy", update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_Selector: bpy.props.StringProperty(name='Selector', default="0", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=5, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_PruneDataAssembly','m_SelectSubtrees','m_AssemblyName','m_ObjectName','m_Selector',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKExtractBlockUsingDataAssembly )        
TYPENAMES.append('VTKExtractBlockUsingDataAssemblyType' )

#--------------------------------------------------------------
class VTKExtractCTHPart(Node, BVTK_Node):

    bl_idname = 'VTKExtractCTHPartType'
    bl_label  = 'vtkExtractCTHPart'
    
    m_Capping: bpy.props.BoolProperty(name='Capping', default=True, update=BVTK_Node.outdate_vtk_status)
    m_GenerateSolidGeometry: bpy.props.BoolProperty(name='GenerateSolidGeometry', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GenerateTriangles: bpy.props.BoolProperty(name='GenerateTriangles', default=True, update=BVTK_Node.outdate_vtk_status)
    m_RemoveGhostCells: bpy.props.BoolProperty(name='RemoveGhostCells', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_VolumeFractionSurfaceValue: bpy.props.FloatProperty(name='VolumeFractionSurfaceValue', default=0.499, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=6, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_Capping','m_GenerateSolidGeometry','m_GenerateTriangles','m_RemoveGhostCells','m_ObjectName','m_VolumeFractionSurfaceValue',]
    def m_connections( self ):
        return (['input'], ['output'], ['ClipPlane'], []) 
    
add_class( VTKExtractCTHPart )        
TYPENAMES.append('VTKExtractCTHPartType' )

#--------------------------------------------------------------
class VTKExtractCells(Node, BVTK_Node):

    bl_idname = 'VTKExtractCellsType'
    bl_label  = 'vtkExtractCells'
    
    m_AssumeSortedAndUniqueIds: bpy.props.BoolProperty(name='AssumeSortedAndUniqueIds', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ExtractAllCells: bpy.props.BoolProperty(name='ExtractAllCells', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=3, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_AssumeSortedAndUniqueIds','m_ExtractAllCells','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKExtractCells )        
TYPENAMES.append('VTKExtractCellsType' )

#--------------------------------------------------------------
class VTKExtractCellsByType(Node, BVTK_Node):

    bl_idname = 'VTKExtractCellsByTypeType'
    bl_label  = 'vtkExtractCellsByType'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKExtractCellsByType )        
TYPENAMES.append('VTKExtractCellsByTypeType' )

#--------------------------------------------------------------
class VTKExtractDataArraysOverTime(Node, BVTK_Node):

    bl_idname = 'VTKExtractDataArraysOverTimeType'
    bl_label  = 'vtkExtractDataArraysOverTime'
    
    m_ReportStatisticsOnly: bpy.props.BoolProperty(name='ReportStatisticsOnly', default=False, update=BVTK_Node.outdate_vtk_status)
    m_UseGlobalIDs: bpy.props.BoolProperty(name='UseGlobalIDs', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_FieldAssociation: bpy.props.IntProperty(name='FieldAssociation', default=0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=4, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ReportStatisticsOnly','m_UseGlobalIDs','m_ObjectName','m_FieldAssociation',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKExtractDataArraysOverTime )        
TYPENAMES.append('VTKExtractDataArraysOverTimeType' )

#--------------------------------------------------------------
class VTKExtractDataOverTime(Node, BVTK_Node):

    bl_idname = 'VTKExtractDataOverTimeType'
    bl_label  = 'vtkExtractDataOverTime'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_PointIndex: bpy.props.IntProperty(name='PointIndex', default=0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_PointIndex',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKExtractDataOverTime )        
TYPENAMES.append('VTKExtractDataOverTimeType' )

#--------------------------------------------------------------
class VTKExtractDataSets(Node, BVTK_Node):

    bl_idname = 'VTKExtractDataSetsType'
    bl_label  = 'vtkExtractDataSets'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKExtractDataSets )        
TYPENAMES.append('VTKExtractDataSetsType' )

#--------------------------------------------------------------
class VTKExtractEdges(Node, BVTK_Node):

    bl_idname = 'VTKExtractEdgesType'
    bl_label  = 'vtkExtractEdges'
    
    m_UseAllPoints: bpy.props.BoolProperty(name='UseAllPoints', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_UseAllPoints','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKExtractEdges )        
TYPENAMES.append('VTKExtractEdgesType' )

#--------------------------------------------------------------
class VTKExtractExodusGlobalTemporalVariables(Node, BVTK_Node):

    bl_idname = 'VTKExtractExodusGlobalTemporalVariablesType'
    bl_label  = 'vtkExtractExodusGlobalTemporalVariables'
    
    m_AutoDetectGlobalTemporalDataArrays: bpy.props.BoolProperty(name='AutoDetectGlobalTemporalDataArrays', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_AutoDetectGlobalTemporalDataArrays','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKExtractExodusGlobalTemporalVariables )        
TYPENAMES.append('VTKExtractExodusGlobalTemporalVariablesType' )

#--------------------------------------------------------------
class VTKExtractGeometry(Node, BVTK_Node):

    bl_idname = 'VTKExtractGeometryType'
    bl_label  = 'vtkExtractGeometry'
    
    m_ExtractBoundaryCells: bpy.props.BoolProperty(name='ExtractBoundaryCells', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ExtractInside: bpy.props.BoolProperty(name='ExtractInside', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ExtractOnlyBoundaryCells: bpy.props.BoolProperty(name='ExtractOnlyBoundaryCells', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=4, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ExtractBoundaryCells','m_ExtractInside','m_ExtractOnlyBoundaryCells','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], ['ImplicitFunction'], []) 
    
add_class( VTKExtractGeometry )        
TYPENAMES.append('VTKExtractGeometryType' )

#--------------------------------------------------------------
class VTKExtractGhostCells(Node, BVTK_Node):

    bl_idname = 'VTKExtractGhostCellsType'
    bl_label  = 'vtkExtractGhostCells'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_OutputGhostArrayName: bpy.props.StringProperty(name='OutputGhostArrayName', default="GhostType", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_OutputGhostArrayName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKExtractGhostCells )        
TYPENAMES.append('VTKExtractGhostCellsType' )

#--------------------------------------------------------------
class VTKExtractGrid(Node, BVTK_Node):

    bl_idname = 'VTKExtractGridType'
    bl_label  = 'vtkExtractGrid'
    
    m_IncludeBoundary: bpy.props.BoolProperty(name='IncludeBoundary', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_SampleRate: bpy.props.IntVectorProperty(name='SampleRate', default=[1, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    m_VOI: bpy.props.IntVectorProperty(name='VOI', default=[0, 1000000000, 0, 1000000000, 0, 1000000000], size=6, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=4, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_IncludeBoundary','m_ObjectName','m_SampleRate','m_VOI',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKExtractGrid )        
TYPENAMES.append('VTKExtractGridType' )

#--------------------------------------------------------------
class VTKExtractHistogram(Node, BVTK_Node):

    bl_idname = 'VTKExtractHistogramType'
    bl_label  = 'vtkExtractHistogram'
    
    m_Accumulation: bpy.props.BoolProperty(name='Accumulation', default=False, update=BVTK_Node.outdate_vtk_status)
    m_CalculateAverages: bpy.props.BoolProperty(name='CalculateAverages', default=False, update=BVTK_Node.outdate_vtk_status)
    m_CenterBinsAroundMinAndMax: bpy.props.BoolProperty(name='CenterBinsAroundMinAndMax', default=False, update=BVTK_Node.outdate_vtk_status)
    m_Normalize: bpy.props.BoolProperty(name='Normalize', default=False, update=BVTK_Node.outdate_vtk_status)
    m_UseCustomBinRanges: bpy.props.BoolProperty(name='UseCustomBinRanges', default=False, update=BVTK_Node.outdate_vtk_status)
    m_BinAccumulationArrayName: bpy.props.StringProperty(name='BinAccumulationArrayName', default="bin_accumulation", update=BVTK_Node.outdate_vtk_status)
    m_BinExtentsArrayName: bpy.props.StringProperty(name='BinExtentsArrayName', default="bin_extents", update=BVTK_Node.outdate_vtk_status)
    m_BinValuesArrayName: bpy.props.StringProperty(name='BinValuesArrayName', default="bin_values", update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_BinCount: bpy.props.IntProperty(name='BinCount', default=10, update=BVTK_Node.outdate_vtk_status)
    m_Component: bpy.props.IntProperty(name='Component', default=0, update=BVTK_Node.outdate_vtk_status)
    m_CustomBinRanges: bpy.props.FloatVectorProperty(name='CustomBinRanges', default=[0.0, 100.0], size=2, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=12, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_Accumulation','m_CalculateAverages','m_CenterBinsAroundMinAndMax','m_Normalize','m_UseCustomBinRanges','m_BinAccumulationArrayName','m_BinExtentsArrayName','m_BinValuesArrayName','m_ObjectName','m_BinCount','m_Component','m_CustomBinRanges',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKExtractHistogram )        
TYPENAMES.append('VTKExtractHistogramType' )

#--------------------------------------------------------------
class VTKExtractLevel(Node, BVTK_Node):

    bl_idname = 'VTKExtractLevelType'
    bl_label  = 'vtkExtractLevel'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKExtractLevel )        
TYPENAMES.append('VTKExtractLevelType' )

#--------------------------------------------------------------
class VTKExtractPiece(Node, BVTK_Node):

    bl_idname = 'VTKExtractPieceType'
    bl_label  = 'vtkExtractPiece'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKExtractPiece )        
TYPENAMES.append('VTKExtractPieceType' )

#--------------------------------------------------------------
class VTKExtractPointCloudPiece(Node, BVTK_Node):

    bl_idname = 'VTKExtractPointCloudPieceType'
    bl_label  = 'vtkExtractPointCloudPiece'
    
    m_ModuloOrdering: bpy.props.BoolProperty(name='ModuloOrdering', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ModuloOrdering','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKExtractPointCloudPiece )        
TYPENAMES.append('VTKExtractPointCloudPieceType' )

#--------------------------------------------------------------
class VTKExtractPolyDataGeometry(Node, BVTK_Node):

    bl_idname = 'VTKExtractPolyDataGeometryType'
    bl_label  = 'vtkExtractPolyDataGeometry'
    
    m_ExtractBoundaryCells: bpy.props.BoolProperty(name='ExtractBoundaryCells', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ExtractInside: bpy.props.BoolProperty(name='ExtractInside', default=True, update=BVTK_Node.outdate_vtk_status)
    m_PassPoints: bpy.props.BoolProperty(name='PassPoints', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=4, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ExtractBoundaryCells','m_ExtractInside','m_PassPoints','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], ['ImplicitFunction'], []) 
    
add_class( VTKExtractPolyDataGeometry )        
TYPENAMES.append('VTKExtractPolyDataGeometryType' )

#--------------------------------------------------------------
class VTKExtractPolyDataPiece(Node, BVTK_Node):

    bl_idname = 'VTKExtractPolyDataPieceType'
    bl_label  = 'vtkExtractPolyDataPiece'
    
    m_CreateGhostCells: bpy.props.BoolProperty(name='CreateGhostCells', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_CreateGhostCells','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKExtractPolyDataPiece )        
TYPENAMES.append('VTKExtractPolyDataPieceType' )

#--------------------------------------------------------------
class VTKExtractRectilinearGrid(Node, BVTK_Node):

    bl_idname = 'VTKExtractRectilinearGridType'
    bl_label  = 'vtkExtractRectilinearGrid'
    
    m_IncludeBoundary: bpy.props.BoolProperty(name='IncludeBoundary', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_SampleRate: bpy.props.IntVectorProperty(name='SampleRate', default=[1, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    m_VOI: bpy.props.IntVectorProperty(name='VOI', default=[0, 1000000000, 0, 1000000000, 0, 1000000000], size=6, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=4, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_IncludeBoundary','m_ObjectName','m_SampleRate','m_VOI',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKExtractRectilinearGrid )        
TYPENAMES.append('VTKExtractRectilinearGridType' )

#--------------------------------------------------------------
class VTKExtractSubsetWithSeed(Node, BVTK_Node):

    bl_idname = 'VTKExtractSubsetWithSeedType'
    bl_label  = 'vtkExtractSubsetWithSeed'
    e_Direction_items=[ (x,x,x) for x in ['LineI', 'LineJ', 'LineK', 'PlaneIJ', 'PlaneJK', 'PlaneKI']]
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    e_Direction: bpy.props.EnumProperty(name='Direction', default="LineI", items=e_Direction_items, update=BVTK_Node.outdate_vtk_status)
    m_Seed: bpy.props.FloatVectorProperty(name='Seed', default=[0.0, 0.0, 0.0], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=3, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','e_Direction','m_Seed',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKExtractSubsetWithSeed )        
TYPENAMES.append('VTKExtractSubsetWithSeedType' )

#--------------------------------------------------------------
class VTKExtractSurface(Node, BVTK_Node):

    bl_idname = 'VTKExtractSurfaceType'
    bl_label  = 'vtkExtractSurface'
    
    m_ComputeGradients: bpy.props.BoolProperty(name='ComputeGradients', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ComputeNormals: bpy.props.BoolProperty(name='ComputeNormals', default=True, update=BVTK_Node.outdate_vtk_status)
    m_HoleFilling: bpy.props.BoolProperty(name='HoleFilling', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_Radius: bpy.props.FloatProperty(name='Radius', default=0.1, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=5, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ComputeGradients','m_ComputeNormals','m_HoleFilling','m_ObjectName','m_Radius',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKExtractSurface )        
TYPENAMES.append('VTKExtractSurfaceType' )

#--------------------------------------------------------------
class VTKExtractTensorComponents(Node, BVTK_Node):

    bl_idname = 'VTKExtractTensorComponentsType'
    bl_label  = 'vtkExtractTensorComponents'
    e_ScalarMode_items=[ (x,x,x) for x in ['Component', 'EffectiveStress', 'Determinant', 'NonNegativeDeterminant', 'Trace']]
    
    m_ExtractNormals: bpy.props.BoolProperty(name='ExtractNormals', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ExtractScalars: bpy.props.BoolProperty(name='ExtractScalars', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ExtractTCoords: bpy.props.BoolProperty(name='ExtractTCoords', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ExtractVectors: bpy.props.BoolProperty(name='ExtractVectors', default=True, update=BVTK_Node.outdate_vtk_status)
    m_NormalizeNormals: bpy.props.BoolProperty(name='NormalizeNormals', default=True, update=BVTK_Node.outdate_vtk_status)
    m_PassTensorsToOutput: bpy.props.BoolProperty(name='PassTensorsToOutput', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_NumberOfTCoords: bpy.props.IntProperty(name='NumberOfTCoords', default=2, update=BVTK_Node.outdate_vtk_status)
    m_OutputPrecision: bpy.props.IntProperty(name='OutputPrecision', default=2, update=BVTK_Node.outdate_vtk_status)
    e_ScalarMode: bpy.props.EnumProperty(name='ScalarMode', default="Component", items=e_ScalarMode_items, update=BVTK_Node.outdate_vtk_status)
    m_NormalComponents: bpy.props.IntVectorProperty(name='NormalComponents', default=[0, 1, 1, 1, 2, 1], size=6, update=BVTK_Node.outdate_vtk_status)
    m_ScalarComponents: bpy.props.IntVectorProperty(name='ScalarComponents', default=[0, 0], size=2, update=BVTK_Node.outdate_vtk_status)
    m_TCoordComponents: bpy.props.IntVectorProperty(name='TCoordComponents', default=[0, 2, 1, 2, 2, 2], size=6, update=BVTK_Node.outdate_vtk_status)
    m_VectorComponents: bpy.props.IntVectorProperty(name='VectorComponents', default=[0, 0, 1, 0, 2, 0], size=6, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=14, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ExtractNormals','m_ExtractScalars','m_ExtractTCoords','m_ExtractVectors','m_NormalizeNormals','m_PassTensorsToOutput','m_ObjectName','m_NumberOfTCoords','m_OutputPrecision','e_ScalarMode','m_NormalComponents','m_ScalarComponents','m_TCoordComponents','m_VectorComponents',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKExtractTensorComponents )        
TYPENAMES.append('VTKExtractTensorComponentsType' )

#--------------------------------------------------------------
class VTKExtractTimeSteps(Node, BVTK_Node):

    bl_idname = 'VTKExtractTimeStepsType'
    bl_label  = 'vtkExtractTimeSteps'
    e_TimeEstimationMode_items=[ (x,x,x) for x in ['Previous', 'Next', 'Nearest']]
    
    m_UseRange: bpy.props.BoolProperty(name='UseRange', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_TimeStepInterval: bpy.props.IntProperty(name='TimeStepInterval', default=1, update=BVTK_Node.outdate_vtk_status)
    e_TimeEstimationMode: bpy.props.EnumProperty(name='TimeEstimationMode', default="Previous", items=e_TimeEstimationMode_items, update=BVTK_Node.outdate_vtk_status)
    m_Range: bpy.props.IntVectorProperty(name='Range', default=[0, 0], size=2, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=5, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_UseRange','m_ObjectName','m_TimeStepInterval','e_TimeEstimationMode','m_Range',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKExtractTimeSteps )        
TYPENAMES.append('VTKExtractTimeStepsType' )

#--------------------------------------------------------------
class VTKExtractUnstructuredGrid(Node, BVTK_Node):

    bl_idname = 'VTKExtractUnstructuredGridType'
    bl_label  = 'vtkExtractUnstructuredGrid'
    
    m_CellClipping: bpy.props.BoolProperty(name='CellClipping', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ExtentClipping: bpy.props.BoolProperty(name='ExtentClipping', default=True, update=BVTK_Node.outdate_vtk_status)
    m_Merging: bpy.props.BoolProperty(name='Merging', default=True, update=BVTK_Node.outdate_vtk_status)
    m_PointClipping: bpy.props.BoolProperty(name='PointClipping', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_CellMaximum: bpy.props.IntProperty(name='CellMaximum', default=1000000000, update=BVTK_Node.outdate_vtk_status)
    m_CellMinimum: bpy.props.IntProperty(name='CellMinimum', default=0, update=BVTK_Node.outdate_vtk_status)
    m_PointMaximum: bpy.props.IntProperty(name='PointMaximum', default=1000000000, update=BVTK_Node.outdate_vtk_status)
    m_PointMinimum: bpy.props.IntProperty(name='PointMinimum', default=0, update=BVTK_Node.outdate_vtk_status)
    m_Extent: bpy.props.FloatVectorProperty(name='Extent', default=[-1e+30, 1e+30, -1e+30, 1e+30, -1e+30, 1e+30], size=6, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=10, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_CellClipping','m_ExtentClipping','m_Merging','m_PointClipping','m_ObjectName','m_CellMaximum','m_CellMinimum','m_PointMaximum','m_PointMinimum','m_Extent',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKExtractUnstructuredGrid )        
TYPENAMES.append('VTKExtractUnstructuredGridType' )

#--------------------------------------------------------------
class VTKExtractUnstructuredGridPiece(Node, BVTK_Node):

    bl_idname = 'VTKExtractUnstructuredGridPieceType'
    bl_label  = 'vtkExtractUnstructuredGridPiece'
    
    m_CreateGhostCells: bpy.props.BoolProperty(name='CreateGhostCells', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_CreateGhostCells','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKExtractUnstructuredGridPiece )        
TYPENAMES.append('VTKExtractUnstructuredGridPieceType' )

#--------------------------------------------------------------
class VTKExtractUserDefinedPiece(Node, BVTK_Node):

    bl_idname = 'VTKExtractUserDefinedPieceType'
    bl_label  = 'vtkExtractUserDefinedPiece'
    
    m_CreateGhostCells: bpy.props.BoolProperty(name='CreateGhostCells', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_CreateGhostCells','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKExtractUserDefinedPiece )        
TYPENAMES.append('VTKExtractUserDefinedPieceType' )

#--------------------------------------------------------------
class VTKExtractVOI(Node, BVTK_Node):

    bl_idname = 'VTKExtractVOIType'
    bl_label  = 'vtkExtractVOI'
    
    m_IncludeBoundary: bpy.props.BoolProperty(name='IncludeBoundary', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_SampleRate: bpy.props.IntVectorProperty(name='SampleRate', default=[1, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    m_VOI: bpy.props.IntVectorProperty(name='VOI', default=[0, 1000000000, 0, 1000000000, 0, 1000000000], size=6, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=4, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_IncludeBoundary','m_ObjectName','m_SampleRate','m_VOI',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKExtractVOI )        
TYPENAMES.append('VTKExtractVOIType' )

#--------------------------------------------------------------
class VTKFeatureEdges(Node, BVTK_Node):

    bl_idname = 'VTKFeatureEdgesType'
    bl_label  = 'vtkFeatureEdges'
    
    m_BoundaryEdges: bpy.props.BoolProperty(name='BoundaryEdges', default=True, update=BVTK_Node.outdate_vtk_status)
    m_Coloring: bpy.props.BoolProperty(name='Coloring', default=True, update=BVTK_Node.outdate_vtk_status)
    m_FeatureEdges: bpy.props.BoolProperty(name='FeatureEdges', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ManifoldEdges: bpy.props.BoolProperty(name='ManifoldEdges', default=False, update=BVTK_Node.outdate_vtk_status)
    m_NonManifoldEdges: bpy.props.BoolProperty(name='NonManifoldEdges', default=True, update=BVTK_Node.outdate_vtk_status)
    m_PassLines: bpy.props.BoolProperty(name='PassLines', default=False, update=BVTK_Node.outdate_vtk_status)
    m_RemoveGhostInterfaces: bpy.props.BoolProperty(name='RemoveGhostInterfaces', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_FeatureAngle: bpy.props.FloatProperty(name='FeatureAngle', default=30.0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=9, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_BoundaryEdges','m_Coloring','m_FeatureEdges','m_ManifoldEdges','m_NonManifoldEdges','m_PassLines','m_RemoveGhostInterfaces','m_ObjectName','m_FeatureAngle',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKFeatureEdges )        
TYPENAMES.append('VTKFeatureEdgesType' )

#--------------------------------------------------------------
class VTKFieldDataToAttributeDataFilter(Node, BVTK_Node):

    bl_idname = 'VTKFieldDataToAttributeDataFilterType'
    bl_label  = 'vtkFieldDataToAttributeDataFilter'
    e_InputField_items=[ (x,x,x) for x in ['DataObjectField', 'PointDataField', 'CellDataField']]
    e_OutputAttributeData_items=[ (x,x,x) for x in ['CellData', 'PointData']]
    
    m_DefaultNormalize: bpy.props.BoolProperty(name='DefaultNormalize', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    e_InputField: bpy.props.EnumProperty(name='InputField', default="DataObjectField", items=e_InputField_items, update=BVTK_Node.outdate_vtk_status)
    e_OutputAttributeData: bpy.props.EnumProperty(name='OutputAttributeData', default="PointData", items=e_OutputAttributeData_items, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=4, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_DefaultNormalize','m_ObjectName','e_InputField','e_OutputAttributeData',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKFieldDataToAttributeDataFilter )        
TYPENAMES.append('VTKFieldDataToAttributeDataFilterType' )

#--------------------------------------------------------------
class VTKFillHolesFilter(Node, BVTK_Node):

    bl_idname = 'VTKFillHolesFilterType'
    bl_label  = 'vtkFillHolesFilter'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_HoleSize: bpy.props.FloatProperty(name='HoleSize', default=1.0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_HoleSize',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKFillHolesFilter )        
TYPENAMES.append('VTKFillHolesFilterType' )

#--------------------------------------------------------------
class VTKFiniteElementFieldDistributor(Node, BVTK_Node):

    bl_idname = 'VTKFiniteElementFieldDistributorType'
    bl_label  = 'vtkFiniteElementFieldDistributor'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKFiniteElementFieldDistributor )        
TYPENAMES.append('VTKFiniteElementFieldDistributorType' )

#--------------------------------------------------------------
class VTKFlyingEdges2D(Node, BVTK_Node):

    bl_idname = 'VTKFlyingEdges2DType'
    bl_label  = 'vtkFlyingEdges2D'
    
    m_ComputeScalars: bpy.props.BoolProperty(name='ComputeScalars', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_ArrayComponent: bpy.props.IntProperty(name='ArrayComponent', default=0, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfContours: bpy.props.IntProperty(name='NumberOfContours', default=1, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=4, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ComputeScalars','m_ObjectName','m_ArrayComponent','m_NumberOfContours',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKFlyingEdges2D )        
TYPENAMES.append('VTKFlyingEdges2DType' )

#--------------------------------------------------------------
class VTKFlyingEdges3D(Node, BVTK_Node):

    bl_idname = 'VTKFlyingEdges3DType'
    bl_label  = 'vtkFlyingEdges3D'
    
    m_ComputeGradients: bpy.props.BoolProperty(name='ComputeGradients', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ComputeNormals: bpy.props.BoolProperty(name='ComputeNormals', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ComputeScalars: bpy.props.BoolProperty(name='ComputeScalars', default=True, update=BVTK_Node.outdate_vtk_status)
    m_InterpolateAttributes: bpy.props.BoolProperty(name='InterpolateAttributes', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_ArrayComponent: bpy.props.IntProperty(name='ArrayComponent', default=0, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfContours: bpy.props.IntProperty(name='NumberOfContours', default=1, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=7, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ComputeGradients','m_ComputeNormals','m_ComputeScalars','m_InterpolateAttributes','m_ObjectName','m_ArrayComponent','m_NumberOfContours',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKFlyingEdges3D )        
TYPENAMES.append('VTKFlyingEdges3DType' )

#--------------------------------------------------------------
class VTKFlyingEdgesPlaneCutter(Node, BVTK_Node):

    bl_idname = 'VTKFlyingEdgesPlaneCutterType'
    bl_label  = 'vtkFlyingEdgesPlaneCutter'
    
    m_ComputeNormals: bpy.props.BoolProperty(name='ComputeNormals', default=True, update=BVTK_Node.outdate_vtk_status)
    m_InterpolateAttributes: bpy.props.BoolProperty(name='InterpolateAttributes', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_ArrayComponent: bpy.props.IntProperty(name='ArrayComponent', default=0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=4, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ComputeNormals','m_InterpolateAttributes','m_ObjectName','m_ArrayComponent',]
    def m_connections( self ):
        return (['input'], ['output'], ['Plane'], []) 
    
add_class( VTKFlyingEdgesPlaneCutter )        
TYPENAMES.append('VTKFlyingEdgesPlaneCutterType' )

#--------------------------------------------------------------
class VTKForceTime(Node, BVTK_Node):

    bl_idname = 'VTKForceTimeType'
    bl_label  = 'vtkForceTime'
    
    m_IgnorePipelineTime: bpy.props.BoolProperty(name='IgnorePipelineTime', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_ForcedTime: bpy.props.FloatProperty(name='ForcedTime', default=0.0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=3, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_IgnorePipelineTime','m_ObjectName','m_ForcedTime',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKForceTime )        
TYPENAMES.append('VTKForceTimeType' )

#--------------------------------------------------------------
class VTKGaussianSplatter(Node, BVTK_Node):

    bl_idname = 'VTKGaussianSplatterType'
    bl_label  = 'vtkGaussianSplatter'
    e_AccumulationMode_items=[ (x,x,x) for x in ['Min', 'Max', 'Sum']]
    
    m_Capping: bpy.props.BoolProperty(name='Capping', default=True, update=BVTK_Node.outdate_vtk_status)
    m_NormalWarping: bpy.props.BoolProperty(name='NormalWarping', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ScalarWarping: bpy.props.BoolProperty(name='ScalarWarping', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_CapValue: bpy.props.FloatProperty(name='CapValue', default=0.0, update=BVTK_Node.outdate_vtk_status)
    m_Eccentricity: bpy.props.FloatProperty(name='Eccentricity', default=2.5, update=BVTK_Node.outdate_vtk_status)
    m_ExponentFactor: bpy.props.FloatProperty(name='ExponentFactor', default=-5.0, update=BVTK_Node.outdate_vtk_status)
    m_NullValue: bpy.props.FloatProperty(name='NullValue', default=0.0, update=BVTK_Node.outdate_vtk_status)
    m_Radius: bpy.props.FloatProperty(name='Radius', default=0.1, update=BVTK_Node.outdate_vtk_status)
    m_ScaleFactor: bpy.props.FloatProperty(name='ScaleFactor', default=1.0, update=BVTK_Node.outdate_vtk_status)
    e_AccumulationMode: bpy.props.EnumProperty(name='AccumulationMode', default="Max", items=e_AccumulationMode_items, update=BVTK_Node.outdate_vtk_status)
    m_SampleDimensions: bpy.props.IntVectorProperty(name='SampleDimensions', default=[50, 50, 50], size=3, update=BVTK_Node.outdate_vtk_status)
    m_ModelBounds: bpy.props.FloatVectorProperty(name='ModelBounds', default=[0.0, 0.0, 0.0, 0.0, 0.0, 0.0], size=6, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=13, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_Capping','m_NormalWarping','m_ScalarWarping','m_ObjectName','m_CapValue','m_Eccentricity','m_ExponentFactor','m_NullValue','m_Radius','m_ScaleFactor','e_AccumulationMode','m_SampleDimensions','m_ModelBounds',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKGaussianSplatter )        
TYPENAMES.append('VTKGaussianSplatterType' )

#--------------------------------------------------------------
class VTKGenerateGlobalIds(Node, BVTK_Node):

    bl_idname = 'VTKGenerateGlobalIdsType'
    bl_label  = 'vtkGenerateGlobalIds'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_Tolerance: bpy.props.FloatProperty(name='Tolerance', default=0.0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_Tolerance',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKGenerateGlobalIds )        
TYPENAMES.append('VTKGenerateGlobalIdsType' )

#--------------------------------------------------------------
class VTKGenerateTimeSteps(Node, BVTK_Node):

    bl_idname = 'VTKGenerateTimeStepsType'
    bl_label  = 'vtkGenerateTimeSteps'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKGenerateTimeSteps )        
TYPENAMES.append('VTKGenerateTimeStepsType' )

#--------------------------------------------------------------
class VTKGenericContourFilter(Node, BVTK_Node):

    bl_idname = 'VTKGenericContourFilterType'
    bl_label  = 'vtkGenericContourFilter'
    
    m_ComputeGradients: bpy.props.BoolProperty(name='ComputeGradients', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ComputeNormals: bpy.props.BoolProperty(name='ComputeNormals', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ComputeScalars: bpy.props.BoolProperty(name='ComputeScalars', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_NumberOfContours: bpy.props.IntProperty(name='NumberOfContours', default=1, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=5, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ComputeGradients','m_ComputeNormals','m_ComputeScalars','m_ObjectName','m_NumberOfContours',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKGenericContourFilter )        
TYPENAMES.append('VTKGenericContourFilterType' )

#--------------------------------------------------------------
class VTKGenericCutter(Node, BVTK_Node):

    bl_idname = 'VTKGenericCutterType'
    bl_label  = 'vtkGenericCutter'
    
    m_GenerateCutScalars: bpy.props.BoolProperty(name='GenerateCutScalars', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_NumberOfContours: bpy.props.IntProperty(name='NumberOfContours', default=1, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=3, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_GenerateCutScalars','m_ObjectName','m_NumberOfContours',]
    def m_connections( self ):
        return (['input'], ['output'], ['CutFunction'], []) 
    
add_class( VTKGenericCutter )        
TYPENAMES.append('VTKGenericCutterType' )

#--------------------------------------------------------------
class VTKGenericDataSetTessellator(Node, BVTK_Node):

    bl_idname = 'VTKGenericDataSetTessellatorType'
    bl_label  = 'vtkGenericDataSetTessellator'
    
    m_KeepCellIds: bpy.props.BoolProperty(name='KeepCellIds', default=True, update=BVTK_Node.outdate_vtk_status)
    m_Merging: bpy.props.BoolProperty(name='Merging', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=3, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_KeepCellIds','m_Merging','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKGenericDataSetTessellator )        
TYPENAMES.append('VTKGenericDataSetTessellatorType' )

#--------------------------------------------------------------
class VTKGenericGeometryFilter(Node, BVTK_Node):

    bl_idname = 'VTKGenericGeometryFilterType'
    bl_label  = 'vtkGenericGeometryFilter'
    
    m_CellClipping: bpy.props.BoolProperty(name='CellClipping', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ExtentClipping: bpy.props.BoolProperty(name='ExtentClipping', default=True, update=BVTK_Node.outdate_vtk_status)
    m_Merging: bpy.props.BoolProperty(name='Merging', default=True, update=BVTK_Node.outdate_vtk_status)
    m_PassThroughCellIds: bpy.props.BoolProperty(name='PassThroughCellIds', default=True, update=BVTK_Node.outdate_vtk_status)
    m_PointClipping: bpy.props.BoolProperty(name='PointClipping', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_CellMaximum: bpy.props.IntProperty(name='CellMaximum', default=1000000000, update=BVTK_Node.outdate_vtk_status)
    m_CellMinimum: bpy.props.IntProperty(name='CellMinimum', default=0, update=BVTK_Node.outdate_vtk_status)
    m_PointMaximum: bpy.props.IntProperty(name='PointMaximum', default=1000000000, update=BVTK_Node.outdate_vtk_status)
    m_PointMinimum: bpy.props.IntProperty(name='PointMinimum', default=0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=10, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_CellClipping','m_ExtentClipping','m_Merging','m_PassThroughCellIds','m_PointClipping','m_ObjectName','m_CellMaximum','m_CellMinimum','m_PointMaximum','m_PointMinimum',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKGenericGeometryFilter )        
TYPENAMES.append('VTKGenericGeometryFilterType' )

#--------------------------------------------------------------
class VTKGenericOutlineFilter(Node, BVTK_Node):

    bl_idname = 'VTKGenericOutlineFilterType'
    bl_label  = 'vtkGenericOutlineFilter'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKGenericOutlineFilter )        
TYPENAMES.append('VTKGenericOutlineFilterType' )

#--------------------------------------------------------------
class VTKGhostCellsGenerator(Node, BVTK_Node):

    bl_idname = 'VTKGhostCellsGeneratorType'
    bl_label  = 'vtkGhostCellsGenerator'
    
    m_BuildIfRequired: bpy.props.BoolProperty(name='BuildIfRequired', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_NumberOfGhostLayers: bpy.props.IntProperty(name='NumberOfGhostLayers', default=1, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=3, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_BuildIfRequired','m_ObjectName','m_NumberOfGhostLayers',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKGhostCellsGenerator )        
TYPENAMES.append('VTKGhostCellsGeneratorType' )

#--------------------------------------------------------------
class VTKGradientFilter(Node, BVTK_Node):

    bl_idname = 'VTKGradientFilterType'
    bl_label  = 'vtkGradientFilter'
    
    m_ComputeDivergence: bpy.props.BoolProperty(name='ComputeDivergence', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ComputeGradient: bpy.props.BoolProperty(name='ComputeGradient', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ComputeQCriterion: bpy.props.BoolProperty(name='ComputeQCriterion', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ComputeVorticity: bpy.props.BoolProperty(name='ComputeVorticity', default=True, update=BVTK_Node.outdate_vtk_status)
    m_FasterApproximation: bpy.props.BoolProperty(name='FasterApproximation', default=True, update=BVTK_Node.outdate_vtk_status)
    m_DivergenceArrayName: bpy.props.StringProperty(name='DivergenceArrayName', default="", update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_QCriterionArrayName: bpy.props.StringProperty(name='QCriterionArrayName', default="", update=BVTK_Node.outdate_vtk_status)
    m_ResultArrayName: bpy.props.StringProperty(name='ResultArrayName', default="", update=BVTK_Node.outdate_vtk_status)
    m_VorticityArrayName: bpy.props.StringProperty(name='VorticityArrayName', default="", update=BVTK_Node.outdate_vtk_status)
    m_ContributingCellOption: bpy.props.IntProperty(name='ContributingCellOption', default=0, update=BVTK_Node.outdate_vtk_status)
    m_ReplacementValueOption: bpy.props.IntProperty(name='ReplacementValueOption', default=0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=12, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ComputeDivergence','m_ComputeGradient','m_ComputeQCriterion','m_ComputeVorticity','m_FasterApproximation','m_DivergenceArrayName','m_ObjectName','m_QCriterionArrayName','m_ResultArrayName','m_VorticityArrayName','m_ContributingCellOption','m_ReplacementValueOption',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKGradientFilter )        
TYPENAMES.append('VTKGradientFilterType' )

#--------------------------------------------------------------
class VTKGraphAlgorithm(Node, BVTK_Node):

    bl_idname = 'VTKGraphAlgorithmType'
    bl_label  = 'vtkGraphAlgorithm'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKGraphAlgorithm )        
TYPENAMES.append('VTKGraphAlgorithmType' )

#--------------------------------------------------------------
class VTKGraphLayoutFilter(Node, BVTK_Node):

    bl_idname = 'VTKGraphLayoutFilterType'
    bl_label  = 'vtkGraphLayoutFilter'
    
    m_AutomaticBoundsComputation: bpy.props.BoolProperty(name='AutomaticBoundsComputation', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ThreeDimensionalLayout: bpy.props.BoolProperty(name='ThreeDimensionalLayout', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_MaxNumberOfIterations: bpy.props.IntProperty(name='MaxNumberOfIterations', default=50, update=BVTK_Node.outdate_vtk_status)
    m_CoolDownRate: bpy.props.FloatProperty(name='CoolDownRate', default=10.0, update=BVTK_Node.outdate_vtk_status)
    m_GraphBounds: bpy.props.FloatVectorProperty(name='GraphBounds', default=[-0.5, 0.5, -0.5, 0.5, -0.5, 0.5], size=6, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=6, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_AutomaticBoundsComputation','m_ThreeDimensionalLayout','m_ObjectName','m_MaxNumberOfIterations','m_CoolDownRate','m_GraphBounds',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKGraphLayoutFilter )        
TYPENAMES.append('VTKGraphLayoutFilterType' )

#--------------------------------------------------------------
class VTKGraphToGlyphs(Node, BVTK_Node):

    bl_idname = 'VTKGraphToGlyphsType'
    bl_label  = 'vtkGraphToGlyphs'
    
    m_Filled: bpy.props.BoolProperty(name='Filled', default=True, update=BVTK_Node.outdate_vtk_status)
    m_Scaling: bpy.props.BoolProperty(name='Scaling', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_GlyphType: bpy.props.IntProperty(name='GlyphType', default=7, update=BVTK_Node.outdate_vtk_status)
    m_ScreenSize: bpy.props.FloatProperty(name='ScreenSize', default=10.0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=5, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_Filled','m_Scaling','m_ObjectName','m_GlyphType','m_ScreenSize',]
    def m_connections( self ):
        return (['input'], ['output'], ['Renderer'], []) 
    
add_class( VTKGraphToGlyphs )        
TYPENAMES.append('VTKGraphToGlyphsType' )

#--------------------------------------------------------------
class VTKGraphToPoints(Node, BVTK_Node):

    bl_idname = 'VTKGraphToPointsType'
    bl_label  = 'vtkGraphToPoints'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKGraphToPoints )        
TYPENAMES.append('VTKGraphToPointsType' )

#--------------------------------------------------------------
class VTKGraphWeightEuclideanDistanceFilter(Node, BVTK_Node):

    bl_idname = 'VTKGraphWeightEuclideanDistanceFilterType'
    bl_label  = 'vtkGraphWeightEuclideanDistanceFilter'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKGraphWeightEuclideanDistanceFilter )        
TYPENAMES.append('VTKGraphWeightEuclideanDistanceFilterType' )

#--------------------------------------------------------------
class VTKGreedyTerrainDecimation(Node, BVTK_Node):

    bl_idname = 'VTKGreedyTerrainDecimationType'
    bl_label  = 'vtkGreedyTerrainDecimation'
    e_ErrorMeasure_items=[ (x,x,x) for x in ['NumberOfTriangles', 'SpecifiedReduction', 'AbsoluteError', 'RelativeError']]
    
    m_BoundaryVertexDeletion: bpy.props.BoolProperty(name='BoundaryVertexDeletion', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ComputeNormals: bpy.props.BoolProperty(name='ComputeNormals', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_NumberOfTriangles: bpy.props.IntProperty(name='NumberOfTriangles', default=1000, update=BVTK_Node.outdate_vtk_status)
    m_AbsoluteError: bpy.props.FloatProperty(name='AbsoluteError', default=1.0, update=BVTK_Node.outdate_vtk_status)
    m_Reduction: bpy.props.FloatProperty(name='Reduction', default=0.9, update=BVTK_Node.outdate_vtk_status)
    m_RelativeError: bpy.props.FloatProperty(name='RelativeError', default=0.01, update=BVTK_Node.outdate_vtk_status)
    e_ErrorMeasure: bpy.props.EnumProperty(name='ErrorMeasure', default="SpecifiedReduction", items=e_ErrorMeasure_items, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=8, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_BoundaryVertexDeletion','m_ComputeNormals','m_ObjectName','m_NumberOfTriangles','m_AbsoluteError','m_Reduction','m_RelativeError','e_ErrorMeasure',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKGreedyTerrainDecimation )        
TYPENAMES.append('VTKGreedyTerrainDecimationType' )

#--------------------------------------------------------------
class VTKGridSynchronizedTemplates3D(Node, BVTK_Node):

    bl_idname = 'VTKGridSynchronizedTemplates3DType'
    bl_label  = 'vtkGridSynchronizedTemplates3D'
    
    m_ComputeGradients: bpy.props.BoolProperty(name='ComputeGradients', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ComputeNormals: bpy.props.BoolProperty(name='ComputeNormals', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ComputeScalars: bpy.props.BoolProperty(name='ComputeScalars', default=True, update=BVTK_Node.outdate_vtk_status)
    m_GenerateTriangles: bpy.props.BoolProperty(name='GenerateTriangles', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_NumberOfContours: bpy.props.IntProperty(name='NumberOfContours', default=1, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=6, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ComputeGradients','m_ComputeNormals','m_ComputeScalars','m_GenerateTriangles','m_ObjectName','m_NumberOfContours',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKGridSynchronizedTemplates3D )        
TYPENAMES.append('VTKGridSynchronizedTemplates3DType' )

#--------------------------------------------------------------
class VTKGroupDataSetsFilter(Node, BVTK_Node):

    bl_idname = 'VTKGroupDataSetsFilterType'
    bl_label  = 'vtkGroupDataSetsFilter'
    e_OutputType_items=[ (x,x,x) for x in ['MultiBlockDataSet', 'PartitionedDataSet', 'PartitionedDataSetCollection']]
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    e_OutputType: bpy.props.EnumProperty(name='OutputType', default="PartitionedDataSetCollection", items=e_OutputType_items, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','e_OutputType',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKGroupDataSetsFilter )        
TYPENAMES.append('VTKGroupDataSetsFilterType' )

#--------------------------------------------------------------
class VTKGroupTimeStepsFilter(Node, BVTK_Node):

    bl_idname = 'VTKGroupTimeStepsFilterType'
    bl_label  = 'vtkGroupTimeStepsFilter'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKGroupTimeStepsFilter )        
TYPENAMES.append('VTKGroupTimeStepsFilterType' )

#--------------------------------------------------------------
class VTKHedgeHog(Node, BVTK_Node):

    bl_idname = 'VTKHedgeHogType'
    bl_label  = 'vtkHedgeHog'
    e_VectorMode_items=[ (x,x,x) for x in ['UseVector', 'UseNormal']]
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_ScaleFactor: bpy.props.FloatProperty(name='ScaleFactor', default=1.0, update=BVTK_Node.outdate_vtk_status)
    e_VectorMode: bpy.props.EnumProperty(name='VectorMode', default="UseVector", items=e_VectorMode_items, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=3, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_ScaleFactor','e_VectorMode',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKHedgeHog )        
TYPENAMES.append('VTKHedgeHogType' )

#--------------------------------------------------------------
class VTKHierarchicalBinningFilter(Node, BVTK_Node):

    bl_idname = 'VTKHierarchicalBinningFilterType'
    bl_label  = 'vtkHierarchicalBinningFilter'
    
    m_Automatic: bpy.props.BoolProperty(name='Automatic', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_NumberOfLevels: bpy.props.IntProperty(name='NumberOfLevels', default=3, update=BVTK_Node.outdate_vtk_status)
    m_Divisions: bpy.props.IntVectorProperty(name='Divisions', default=[2, 2, 2], size=3, update=BVTK_Node.outdate_vtk_status)
    m_Bounds: bpy.props.FloatVectorProperty(name='Bounds', default=[0.0, 1.0, 0.0, 1.0, 0.0, 1.0], size=6, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=5, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_Automatic','m_ObjectName','m_NumberOfLevels','m_Divisions','m_Bounds',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKHierarchicalBinningFilter )        
TYPENAMES.append('VTKHierarchicalBinningFilterType' )

#--------------------------------------------------------------
class VTKHierarchicalBoxDataSetAlgorithm(Node, BVTK_Node):

    bl_idname = 'VTKHierarchicalBoxDataSetAlgorithmType'
    bl_label  = 'vtkHierarchicalBoxDataSetAlgorithm'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKHierarchicalBoxDataSetAlgorithm )        
TYPENAMES.append('VTKHierarchicalBoxDataSetAlgorithmType' )

#--------------------------------------------------------------
class VTKHierarchicalDataExtractDataSets(Node, BVTK_Node):

    bl_idname = 'VTKHierarchicalDataExtractDataSetsType'
    bl_label  = 'vtkHierarchicalDataExtractDataSets'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKHierarchicalDataExtractDataSets )        
TYPENAMES.append('VTKHierarchicalDataExtractDataSetsType' )

#--------------------------------------------------------------
class VTKHierarchicalDataExtractLevel(Node, BVTK_Node):

    bl_idname = 'VTKHierarchicalDataExtractLevelType'
    bl_label  = 'vtkHierarchicalDataExtractLevel'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKHierarchicalDataExtractLevel )        
TYPENAMES.append('VTKHierarchicalDataExtractLevelType' )

#--------------------------------------------------------------
class VTKHierarchicalDataLevelFilter(Node, BVTK_Node):

    bl_idname = 'VTKHierarchicalDataLevelFilterType'
    bl_label  = 'vtkHierarchicalDataLevelFilter'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKHierarchicalDataLevelFilter )        
TYPENAMES.append('VTKHierarchicalDataLevelFilterType' )

#--------------------------------------------------------------
class VTKHierarchicalDataSetGeometryFilter(Node, BVTK_Node):

    bl_idname = 'VTKHierarchicalDataSetGeometryFilterType'
    bl_label  = 'vtkHierarchicalDataSetGeometryFilter'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKHierarchicalDataSetGeometryFilter )        
TYPENAMES.append('VTKHierarchicalDataSetGeometryFilterType' )

#--------------------------------------------------------------
class VTKHull(Node, BVTK_Node):

    bl_idname = 'VTKHullType'
    bl_label  = 'vtkHull'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKHull )        
TYPENAMES.append('VTKHullType' )

#--------------------------------------------------------------
class VTKHyperStreamline(Node, BVTK_Node):

    bl_idname = 'VTKHyperStreamlineType'
    bl_label  = 'vtkHyperStreamline'
    e_IntegrationDirection_items=[ (x,x,x) for x in ['Forward', 'Backward', 'IntegrateBothDirections']]
    e_IntegrationEigenvector_items=[ (x,x,x) for x in ['Major', 'Medium', 'Minor']]
    
    m_LogScaling: bpy.props.BoolProperty(name='LogScaling', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_NumberOfSides: bpy.props.IntProperty(name='NumberOfSides', default=6, update=BVTK_Node.outdate_vtk_status)
    m_IntegrationStepLength: bpy.props.FloatProperty(name='IntegrationStepLength', default=0.2, update=BVTK_Node.outdate_vtk_status)
    m_MaximumPropagationDistance: bpy.props.FloatProperty(name='MaximumPropagationDistance', default=100.0, update=BVTK_Node.outdate_vtk_status)
    m_Radius: bpy.props.FloatProperty(name='Radius', default=0.5, update=BVTK_Node.outdate_vtk_status)
    m_StepLength: bpy.props.FloatProperty(name='StepLength', default=0.01, update=BVTK_Node.outdate_vtk_status)
    m_TerminalEigenvalue: bpy.props.FloatProperty(name='TerminalEigenvalue', default=0.0, update=BVTK_Node.outdate_vtk_status)
    e_IntegrationDirection: bpy.props.EnumProperty(name='IntegrationDirection', default="Forward", items=e_IntegrationDirection_items, update=BVTK_Node.outdate_vtk_status)
    e_IntegrationEigenvector: bpy.props.EnumProperty(name='IntegrationEigenvector', default="Major", items=e_IntegrationEigenvector_items, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=10, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_LogScaling','m_ObjectName','m_NumberOfSides','m_IntegrationStepLength','m_MaximumPropagationDistance','m_Radius','m_StepLength','m_TerminalEigenvalue','e_IntegrationDirection','e_IntegrationEigenvector',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKHyperStreamline )        
TYPENAMES.append('VTKHyperStreamlineType' )

#--------------------------------------------------------------
class VTKHyperTreeGridAxisClip(Node, BVTK_Node):

    bl_idname = 'VTKHyperTreeGridAxisClipType'
    bl_label  = 'vtkHyperTreeGridAxisClip'
    e_ClipType_items=[ (x,x,x) for x in ['Plane', 'Box', 'Quadric']]
    
    m_InsideOut: bpy.props.BoolProperty(name='InsideOut', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_PlaneNormalAxis: bpy.props.IntProperty(name='PlaneNormalAxis', default=0, update=BVTK_Node.outdate_vtk_status)
    m_PlanePosition: bpy.props.FloatProperty(name='PlanePosition', default=0.0, update=BVTK_Node.outdate_vtk_status)
    e_ClipType: bpy.props.EnumProperty(name='ClipType', default="Plane", items=e_ClipType_items, update=BVTK_Node.outdate_vtk_status)
    m_Bounds: bpy.props.FloatVectorProperty(name='Bounds', default=[-0.5, 0.5, -0.5, 0.5, -0.5, 0.5], size=6, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=6, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_InsideOut','m_ObjectName','m_PlaneNormalAxis','m_PlanePosition','e_ClipType','m_Bounds',]
    def m_connections( self ):
        return (['input'], ['output'], ['Quadric'], []) 
    
add_class( VTKHyperTreeGridAxisClip )        
TYPENAMES.append('VTKHyperTreeGridAxisClipType' )

#--------------------------------------------------------------
class VTKHyperTreeGridAxisCut(Node, BVTK_Node):

    bl_idname = 'VTKHyperTreeGridAxisCutType'
    bl_label  = 'vtkHyperTreeGridAxisCut'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_PlaneNormalAxis: bpy.props.IntProperty(name='PlaneNormalAxis', default=0, update=BVTK_Node.outdate_vtk_status)
    m_PlanePosition: bpy.props.FloatProperty(name='PlanePosition', default=0.0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=3, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_PlaneNormalAxis','m_PlanePosition',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKHyperTreeGridAxisCut )        
TYPENAMES.append('VTKHyperTreeGridAxisCutType' )

#--------------------------------------------------------------
class VTKHyperTreeGridAxisReflection(Node, BVTK_Node):

    bl_idname = 'VTKHyperTreeGridAxisReflectionType'
    bl_label  = 'vtkHyperTreeGridAxisReflection'
    e_Plane_items=[ (x,x,x) for x in ['XMin', 'YMin', 'ZMin', 'XMax', 'YMax', 'ZMax', 'X', 'Y', 'Z']]
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_Center: bpy.props.FloatProperty(name='Center', default=0.0, update=BVTK_Node.outdate_vtk_status)
    e_Plane: bpy.props.EnumProperty(name='Plane', default="XMin", items=e_Plane_items, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=3, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_Center','e_Plane',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKHyperTreeGridAxisReflection )        
TYPENAMES.append('VTKHyperTreeGridAxisReflectionType' )

#--------------------------------------------------------------
class VTKHyperTreeGridCellCenters(Node, BVTK_Node):

    bl_idname = 'VTKHyperTreeGridCellCentersType'
    bl_label  = 'vtkHyperTreeGridCellCenters'
    
    m_CopyArrays: bpy.props.BoolProperty(name='CopyArrays', default=True, update=BVTK_Node.outdate_vtk_status)
    m_VertexCells: bpy.props.BoolProperty(name='VertexCells', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=3, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_CopyArrays','m_VertexCells','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKHyperTreeGridCellCenters )        
TYPENAMES.append('VTKHyperTreeGridCellCentersType' )

#--------------------------------------------------------------
class VTKHyperTreeGridContour(Node, BVTK_Node):

    bl_idname = 'VTKHyperTreeGridContourType'
    bl_label  = 'vtkHyperTreeGridContour'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_NumberOfContours: bpy.props.IntProperty(name='NumberOfContours', default=1, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_NumberOfContours',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKHyperTreeGridContour )        
TYPENAMES.append('VTKHyperTreeGridContourType' )

#--------------------------------------------------------------
class VTKHyperTreeGridDepthLimiter(Node, BVTK_Node):

    bl_idname = 'VTKHyperTreeGridDepthLimiterType'
    bl_label  = 'vtkHyperTreeGridDepthLimiter'
    
    m_JustCreateNewMask: bpy.props.BoolProperty(name='JustCreateNewMask', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_Depth: bpy.props.IntProperty(name='Depth', default=0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=3, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_JustCreateNewMask','m_ObjectName','m_Depth',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKHyperTreeGridDepthLimiter )        
TYPENAMES.append('VTKHyperTreeGridDepthLimiterType' )

#--------------------------------------------------------------
class VTKHyperTreeGridEvaluateCoarse(Node, BVTK_Node):

    bl_idname = 'VTKHyperTreeGridEvaluateCoarseType'
    bl_label  = 'vtkHyperTreeGridEvaluateCoarse'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_Operator: bpy.props.IntProperty(name='Operator', default=1, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_Operator',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKHyperTreeGridEvaluateCoarse )        
TYPENAMES.append('VTKHyperTreeGridEvaluateCoarseType' )

#--------------------------------------------------------------
class VTKHyperTreeGridGeometry(Node, BVTK_Node):

    bl_idname = 'VTKHyperTreeGridGeometryType'
    bl_label  = 'vtkHyperTreeGridGeometry'
    
    m_Merging: bpy.props.BoolProperty(name='Merging', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_Merging','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKHyperTreeGridGeometry )        
TYPENAMES.append('VTKHyperTreeGridGeometryType' )

#--------------------------------------------------------------
class VTKHyperTreeGridGhostCellsGenerator(Node, BVTK_Node):

    bl_idname = 'VTKHyperTreeGridGhostCellsGeneratorType'
    bl_label  = 'vtkHyperTreeGridGhostCellsGenerator'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKHyperTreeGridGhostCellsGenerator )        
TYPENAMES.append('VTKHyperTreeGridGhostCellsGeneratorType' )

#--------------------------------------------------------------
class VTKHyperTreeGridGradient(Node, BVTK_Node):

    bl_idname = 'VTKHyperTreeGridGradientType'
    bl_label  = 'vtkHyperTreeGridGradient'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_ResultArrayName: bpy.props.StringProperty(name='ResultArrayName', default="Gradient", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_ResultArrayName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKHyperTreeGridGradient )        
TYPENAMES.append('VTKHyperTreeGridGradientType' )

#--------------------------------------------------------------
class VTKHyperTreeGridOutlineFilter(Node, BVTK_Node):

    bl_idname = 'VTKHyperTreeGridOutlineFilterType'
    bl_label  = 'vtkHyperTreeGridOutlineFilter'
    
    m_GenerateFaces: bpy.props.BoolProperty(name='GenerateFaces', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_GenerateFaces','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKHyperTreeGridOutlineFilter )        
TYPENAMES.append('VTKHyperTreeGridOutlineFilterType' )

#--------------------------------------------------------------
class VTKHyperTreeGridPlaneCutter(Node, BVTK_Node):

    bl_idname = 'VTKHyperTreeGridPlaneCutterType'
    bl_label  = 'vtkHyperTreeGridPlaneCutter'
    
    m_Dual: bpy.props.BoolProperty(name='Dual', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_Plane: bpy.props.FloatVectorProperty(name='Plane', default=[0.0, 0.0, 0.0, 0.0], size=4, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=3, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_Dual','m_ObjectName','m_Plane',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKHyperTreeGridPlaneCutter )        
TYPENAMES.append('VTKHyperTreeGridPlaneCutterType' )

#--------------------------------------------------------------
class VTKHyperTreeGridThreshold(Node, BVTK_Node):

    bl_idname = 'VTKHyperTreeGridThresholdType'
    bl_label  = 'vtkHyperTreeGridThreshold'
    
    m_JustCreateNewMask: bpy.props.BoolProperty(name='JustCreateNewMask', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_LowerThreshold: bpy.props.FloatProperty(name='LowerThreshold', default=2.2250738585072014e-308, update=BVTK_Node.outdate_vtk_status)
    m_UpperThreshold: bpy.props.FloatProperty(name='UpperThreshold', default=1e+30, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=4, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_JustCreateNewMask','m_ObjectName','m_LowerThreshold','m_UpperThreshold',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKHyperTreeGridThreshold )        
TYPENAMES.append('VTKHyperTreeGridThresholdType' )

#--------------------------------------------------------------
class VTKHyperTreeGridToDualGrid(Node, BVTK_Node):

    bl_idname = 'VTKHyperTreeGridToDualGridType'
    bl_label  = 'vtkHyperTreeGridToDualGrid'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKHyperTreeGridToDualGrid )        
TYPENAMES.append('VTKHyperTreeGridToDualGridType' )

#--------------------------------------------------------------
class VTKHyperTreeGridToUnstructuredGrid(Node, BVTK_Node):

    bl_idname = 'VTKHyperTreeGridToUnstructuredGridType'
    bl_label  = 'vtkHyperTreeGridToUnstructuredGrid'
    
    m_AddOriginalIds: bpy.props.BoolProperty(name='AddOriginalIds', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_AddOriginalIds','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKHyperTreeGridToUnstructuredGrid )        
TYPENAMES.append('VTKHyperTreeGridToUnstructuredGridType' )

#--------------------------------------------------------------
class VTKIconGlyphFilter(Node, BVTK_Node):

    bl_idname = 'VTKIconGlyphFilterType'
    bl_label  = 'vtkIconGlyphFilter'
    e_Gravity_items=[ (x,x,x) for x in ['TopRight', 'TopCenter', 'TopLeft', 'CenterRight', 'CenterCenter', 'CenterLeft', 'BottomRight', 'BottomCenter', 'BottomLeft']]
    e_IconScaling_items=[ (x,x,x) for x in ['ScalingOff', 'ScalingArray']]
    
    m_PassScalars: bpy.props.BoolProperty(name='PassScalars', default=False, update=BVTK_Node.outdate_vtk_status)
    m_UseIconSize: bpy.props.BoolProperty(name='UseIconSize', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    e_Gravity: bpy.props.EnumProperty(name='Gravity', default="CenterCenter", items=e_Gravity_items, update=BVTK_Node.outdate_vtk_status)
    e_IconScaling: bpy.props.EnumProperty(name='IconScaling', default="ScalingOff", items=e_IconScaling_items, update=BVTK_Node.outdate_vtk_status)
    m_DisplaySize: bpy.props.IntVectorProperty(name='DisplaySize', default=[25, 25], size=2, update=BVTK_Node.outdate_vtk_status)
    m_IconSheetSize: bpy.props.IntVectorProperty(name='IconSheetSize', default=[1, 1], size=2, update=BVTK_Node.outdate_vtk_status)
    m_IconSize: bpy.props.IntVectorProperty(name='IconSize', default=[1, 1], size=2, update=BVTK_Node.outdate_vtk_status)
    m_Offset: bpy.props.IntVectorProperty(name='Offset', default=[0, 0], size=2, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=9, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_PassScalars','m_UseIconSize','m_ObjectName','e_Gravity','e_IconScaling','m_DisplaySize','m_IconSheetSize','m_IconSize','m_Offset',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKIconGlyphFilter )        
TYPENAMES.append('VTKIconGlyphFilterType' )

#--------------------------------------------------------------
class VTKIdFilter(Node, BVTK_Node):

    bl_idname = 'VTKIdFilterType'
    bl_label  = 'vtkIdFilter'
    
    m_CellIds: bpy.props.BoolProperty(name='CellIds', default=True, update=BVTK_Node.outdate_vtk_status)
    m_FieldData: bpy.props.BoolProperty(name='FieldData', default=True, update=BVTK_Node.outdate_vtk_status)
    m_PointIds: bpy.props.BoolProperty(name='PointIds', default=True, update=BVTK_Node.outdate_vtk_status)
    m_CellIdsArrayName: bpy.props.StringProperty(name='CellIdsArrayName', default="vtkIdFilter_Ids", update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_PointIdsArrayName: bpy.props.StringProperty(name='PointIdsArrayName', default="vtkIdFilter_Ids", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=6, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_CellIds','m_FieldData','m_PointIds','m_CellIdsArrayName','m_ObjectName','m_PointIdsArrayName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKIdFilter )        
TYPENAMES.append('VTKIdFilterType' )

#--------------------------------------------------------------
class VTKImageAnisotropicDiffusion2D(Node, BVTK_Node):

    bl_idname = 'VTKImageAnisotropicDiffusion2DType'
    bl_label  = 'vtkImageAnisotropicDiffusion2D'
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_Corners: bpy.props.BoolProperty(name='Corners', default=True, update=BVTK_Node.outdate_vtk_status)
    m_Edges: bpy.props.BoolProperty(name='Edges', default=True, update=BVTK_Node.outdate_vtk_status)
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_Faces: bpy.props.BoolProperty(name='Faces', default=True, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GradientMagnitudeThreshold: bpy.props.BoolProperty(name='GradientMagnitudeThreshold', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfIterations: bpy.props.IntProperty(name='NumberOfIterations', default=4, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    m_DiffusionFactor: bpy.props.FloatProperty(name='DiffusionFactor', default=1.0, update=BVTK_Node.outdate_vtk_status)
    m_DiffusionThreshold: bpy.props.FloatProperty(name='DiffusionThreshold', default=5.0, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=14, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_Corners','m_Edges','m_EnableSMP','m_Faces','m_GlobalDefaultEnableSMP','m_GradientMagnitudeThreshold','m_ObjectName','m_DesiredBytesPerPiece','m_NumberOfIterations','m_NumberOfThreads','m_DiffusionFactor','m_DiffusionThreshold','e_SplitMode','m_MinimumPieceSize',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageAnisotropicDiffusion2D )        
TYPENAMES.append('VTKImageAnisotropicDiffusion2DType' )

#--------------------------------------------------------------
class VTKImageAnisotropicDiffusion3D(Node, BVTK_Node):

    bl_idname = 'VTKImageAnisotropicDiffusion3DType'
    bl_label  = 'vtkImageAnisotropicDiffusion3D'
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_Corners: bpy.props.BoolProperty(name='Corners', default=True, update=BVTK_Node.outdate_vtk_status)
    m_Edges: bpy.props.BoolProperty(name='Edges', default=True, update=BVTK_Node.outdate_vtk_status)
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_Faces: bpy.props.BoolProperty(name='Faces', default=True, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GradientMagnitudeThreshold: bpy.props.BoolProperty(name='GradientMagnitudeThreshold', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfIterations: bpy.props.IntProperty(name='NumberOfIterations', default=4, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    m_DiffusionFactor: bpy.props.FloatProperty(name='DiffusionFactor', default=1.0, update=BVTK_Node.outdate_vtk_status)
    m_DiffusionThreshold: bpy.props.FloatProperty(name='DiffusionThreshold', default=5.0, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=14, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_Corners','m_Edges','m_EnableSMP','m_Faces','m_GlobalDefaultEnableSMP','m_GradientMagnitudeThreshold','m_ObjectName','m_DesiredBytesPerPiece','m_NumberOfIterations','m_NumberOfThreads','m_DiffusionFactor','m_DiffusionThreshold','e_SplitMode','m_MinimumPieceSize',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageAnisotropicDiffusion3D )        
TYPENAMES.append('VTKImageAnisotropicDiffusion3DType' )

#--------------------------------------------------------------
class VTKImageAppend(Node, BVTK_Node):

    bl_idname = 'VTKImageAppendType'
    bl_label  = 'vtkImageAppend'
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_PreserveExtents: bpy.props.BoolProperty(name='PreserveExtents', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_AppendAxis: bpy.props.IntProperty(name='AppendAxis', default=0, update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=9, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_EnableSMP','m_GlobalDefaultEnableSMP','m_PreserveExtents','m_ObjectName','m_AppendAxis','m_DesiredBytesPerPiece','m_NumberOfThreads','e_SplitMode','m_MinimumPieceSize',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageAppend )        
TYPENAMES.append('VTKImageAppendType' )

#--------------------------------------------------------------
class VTKImageAppendComponents(Node, BVTK_Node):

    bl_idname = 'VTKImageAppendComponentsType'
    bl_label  = 'vtkImageAppendComponents'
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=7, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_EnableSMP','m_GlobalDefaultEnableSMP','m_ObjectName','m_DesiredBytesPerPiece','m_NumberOfThreads','e_SplitMode','m_MinimumPieceSize',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageAppendComponents )        
TYPENAMES.append('VTKImageAppendComponentsType' )

#--------------------------------------------------------------
class VTKImageBSplineCoefficients(Node, BVTK_Node):

    bl_idname = 'VTKImageBSplineCoefficientsType'
    bl_label  = 'vtkImageBSplineCoefficients'
    e_OutputScalarType_items=[ (x,x,x) for x in ['Float', 'Double']]
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_Bypass: bpy.props.BoolProperty(name='Bypass', default=True, update=BVTK_Node.outdate_vtk_status)
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    m_SplineDegree: bpy.props.IntProperty(name='SplineDegree', default=3, update=BVTK_Node.outdate_vtk_status)
    e_OutputScalarType: bpy.props.EnumProperty(name='OutputScalarType', default="Float", items=e_OutputScalarType_items, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=10, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_Bypass','m_EnableSMP','m_GlobalDefaultEnableSMP','m_ObjectName','m_DesiredBytesPerPiece','m_NumberOfThreads','m_SplineDegree','e_OutputScalarType','e_SplitMode','m_MinimumPieceSize',]
    def m_connections( self ):
        return (['input'], ['output'], ['BorderMode'], []) 
    
add_class( VTKImageBSplineCoefficients )        
TYPENAMES.append('VTKImageBSplineCoefficientsType' )

#--------------------------------------------------------------
class VTKImageButterworthHighPass(Node, BVTK_Node):

    bl_idname = 'VTKImageButterworthHighPassType'
    bl_label  = 'vtkImageButterworthHighPass'
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    m_Order: bpy.props.IntProperty(name='Order', default=1, update=BVTK_Node.outdate_vtk_status)
    m_XCutOff: bpy.props.FloatProperty(name='XCutOff', default=1e+30, update=BVTK_Node.outdate_vtk_status)
    m_YCutOff: bpy.props.FloatProperty(name='YCutOff', default=1e+30, update=BVTK_Node.outdate_vtk_status)
    m_ZCutOff: bpy.props.FloatProperty(name='ZCutOff', default=1e+30, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    m_CutOff: bpy.props.FloatVectorProperty(name='CutOff', default=[1e+30, 1e+30, 1e+30], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=12, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_EnableSMP','m_GlobalDefaultEnableSMP','m_ObjectName','m_DesiredBytesPerPiece','m_NumberOfThreads','m_Order','m_XCutOff','m_YCutOff','m_ZCutOff','e_SplitMode','m_MinimumPieceSize','m_CutOff',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageButterworthHighPass )        
TYPENAMES.append('VTKImageButterworthHighPassType' )

#--------------------------------------------------------------
class VTKImageButterworthLowPass(Node, BVTK_Node):

    bl_idname = 'VTKImageButterworthLowPassType'
    bl_label  = 'vtkImageButterworthLowPass'
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    m_Order: bpy.props.IntProperty(name='Order', default=1, update=BVTK_Node.outdate_vtk_status)
    m_XCutOff: bpy.props.FloatProperty(name='XCutOff', default=1e+30, update=BVTK_Node.outdate_vtk_status)
    m_YCutOff: bpy.props.FloatProperty(name='YCutOff', default=1e+30, update=BVTK_Node.outdate_vtk_status)
    m_ZCutOff: bpy.props.FloatProperty(name='ZCutOff', default=1e+30, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    m_CutOff: bpy.props.FloatVectorProperty(name='CutOff', default=[1e+30, 1e+30, 1e+30], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=12, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_EnableSMP','m_GlobalDefaultEnableSMP','m_ObjectName','m_DesiredBytesPerPiece','m_NumberOfThreads','m_Order','m_XCutOff','m_YCutOff','m_ZCutOff','e_SplitMode','m_MinimumPieceSize','m_CutOff',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageButterworthLowPass )        
TYPENAMES.append('VTKImageButterworthLowPassType' )

#--------------------------------------------------------------
class VTKImageCacheFilter(Node, BVTK_Node):

    bl_idname = 'VTKImageCacheFilterType'
    bl_label  = 'vtkImageCacheFilter'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_CacheSize: bpy.props.IntProperty(name='CacheSize', default=10, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_CacheSize',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageCacheFilter )        
TYPENAMES.append('VTKImageCacheFilterType' )

#--------------------------------------------------------------
class VTKImageCast(Node, BVTK_Node):

    bl_idname = 'VTKImageCastType'
    bl_label  = 'vtkImageCast'
    e_OutputScalarType_items=[ (x,x,x) for x in ['Char', 'UnsignedChar', 'Short', 'UnsignedShort', 'Int', 'UnsignedInt', 'Long', 'UnsignedLong', 'Float', 'Double']]
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_ClampOverflow: bpy.props.BoolProperty(name='ClampOverflow', default=True, update=BVTK_Node.outdate_vtk_status)
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    e_OutputScalarType: bpy.props.EnumProperty(name='OutputScalarType', default="Float", items=e_OutputScalarType_items, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=9, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ClampOverflow','m_EnableSMP','m_GlobalDefaultEnableSMP','m_ObjectName','m_DesiredBytesPerPiece','m_NumberOfThreads','e_OutputScalarType','e_SplitMode','m_MinimumPieceSize',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageCast )        
TYPENAMES.append('VTKImageCastType' )

#--------------------------------------------------------------
class VTKImageCityBlockDistance(Node, BVTK_Node):

    bl_idname = 'VTKImageCityBlockDistanceType'
    bl_label  = 'vtkImageCityBlockDistance'
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_Dimensionality: bpy.props.IntProperty(name='Dimensionality', default=3, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=8, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_EnableSMP','m_GlobalDefaultEnableSMP','m_ObjectName','m_DesiredBytesPerPiece','m_Dimensionality','m_NumberOfThreads','e_SplitMode','m_MinimumPieceSize',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageCityBlockDistance )        
TYPENAMES.append('VTKImageCityBlockDistanceType' )

#--------------------------------------------------------------
class VTKImageClip(Node, BVTK_Node):

    bl_idname = 'VTKImageClipType'
    bl_label  = 'vtkImageClip'
    
    m_ClipData: bpy.props.BoolProperty(name='ClipData', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ClipData','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageClip )        
TYPENAMES.append('VTKImageClipType' )

#--------------------------------------------------------------
class VTKImageConstantPad(Node, BVTK_Node):

    bl_idname = 'VTKImageConstantPadType'
    bl_label  = 'vtkImageConstantPad'
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    m_OutputNumberOfScalarComponents: bpy.props.IntProperty(name='OutputNumberOfScalarComponents', default=-1, update=BVTK_Node.outdate_vtk_status)
    m_Constant: bpy.props.FloatProperty(name='Constant', default=0.0, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=9, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_EnableSMP','m_GlobalDefaultEnableSMP','m_ObjectName','m_DesiredBytesPerPiece','m_NumberOfThreads','m_OutputNumberOfScalarComponents','m_Constant','e_SplitMode','m_MinimumPieceSize',]
    def m_connections( self ):
        return (['input'], ['output'], ['OutputWholeExtent'], []) 
    
add_class( VTKImageConstantPad )        
TYPENAMES.append('VTKImageConstantPadType' )

#--------------------------------------------------------------
class VTKImageContinuousDilate3D(Node, BVTK_Node):

    bl_idname = 'VTKImageContinuousDilate3DType'
    bl_label  = 'vtkImageContinuousDilate3D'
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_KernelSize: bpy.props.IntVectorProperty(name='KernelSize', default=[1, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=8, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_EnableSMP','m_GlobalDefaultEnableSMP','m_ObjectName','m_DesiredBytesPerPiece','m_NumberOfThreads','e_SplitMode','m_KernelSize','m_MinimumPieceSize',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageContinuousDilate3D )        
TYPENAMES.append('VTKImageContinuousDilate3DType' )

#--------------------------------------------------------------
class VTKImageContinuousErode3D(Node, BVTK_Node):

    bl_idname = 'VTKImageContinuousErode3DType'
    bl_label  = 'vtkImageContinuousErode3D'
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_KernelSize: bpy.props.IntVectorProperty(name='KernelSize', default=[1, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=8, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_EnableSMP','m_GlobalDefaultEnableSMP','m_ObjectName','m_DesiredBytesPerPiece','m_NumberOfThreads','e_SplitMode','m_KernelSize','m_MinimumPieceSize',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageContinuousErode3D )        
TYPENAMES.append('VTKImageContinuousErode3DType' )

#--------------------------------------------------------------
class VTKImageConvolve(Node, BVTK_Node):

    bl_idname = 'VTKImageConvolveType'
    bl_label  = 'vtkImageConvolve'
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=7, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_EnableSMP','m_GlobalDefaultEnableSMP','m_ObjectName','m_DesiredBytesPerPiece','m_NumberOfThreads','e_SplitMode','m_MinimumPieceSize',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageConvolve )        
TYPENAMES.append('VTKImageConvolveType' )

#--------------------------------------------------------------
class VTKImageCursor3D(Node, BVTK_Node):

    bl_idname = 'VTKImageCursor3DType'
    bl_label  = 'vtkImageCursor3D'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_CursorRadius: bpy.props.IntProperty(name='CursorRadius', default=5, update=BVTK_Node.outdate_vtk_status)
    m_CursorValue: bpy.props.FloatProperty(name='CursorValue', default=255.0, update=BVTK_Node.outdate_vtk_status)
    m_CursorPosition: bpy.props.FloatVectorProperty(name='CursorPosition', default=[0.0, 0.0, 0.0], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=4, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_CursorRadius','m_CursorValue','m_CursorPosition',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageCursor3D )        
TYPENAMES.append('VTKImageCursor3DType' )

#--------------------------------------------------------------
class VTKImageDataGeometryFilter(Node, BVTK_Node):

    bl_idname = 'VTKImageDataGeometryFilterType'
    bl_label  = 'vtkImageDataGeometryFilter'
    
    m_OutputTriangles: bpy.props.BoolProperty(name='OutputTriangles', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ThresholdCells: bpy.props.BoolProperty(name='ThresholdCells', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ThresholdValue: bpy.props.BoolProperty(name='ThresholdValue', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=4, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_OutputTriangles','m_ThresholdCells','m_ThresholdValue','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageDataGeometryFilter )        
TYPENAMES.append('VTKImageDataGeometryFilterType' )

#--------------------------------------------------------------
class VTKImageDataOutlineFilter(Node, BVTK_Node):

    bl_idname = 'VTKImageDataOutlineFilterType'
    bl_label  = 'vtkImageDataOutlineFilter'
    
    m_GenerateFaces: bpy.props.BoolProperty(name='GenerateFaces', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_GenerateFaces','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageDataOutlineFilter )        
TYPENAMES.append('VTKImageDataOutlineFilterType' )

#--------------------------------------------------------------
class VTKImageDataStreamer(Node, BVTK_Node):

    bl_idname = 'VTKImageDataStreamerType'
    bl_label  = 'vtkImageDataStreamer'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_NumberOfStreamDivisions: bpy.props.IntProperty(name='NumberOfStreamDivisions', default=10, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_NumberOfStreamDivisions',]
    def m_connections( self ):
        return (['input'], ['output'], ['ExtentTranslator'], []) 
    
add_class( VTKImageDataStreamer )        
TYPENAMES.append('VTKImageDataStreamerType' )

#--------------------------------------------------------------
class VTKImageDataToExplicitStructuredGrid(Node, BVTK_Node):

    bl_idname = 'VTKImageDataToExplicitStructuredGridType'
    bl_label  = 'vtkImageDataToExplicitStructuredGrid'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageDataToExplicitStructuredGrid )        
TYPENAMES.append('VTKImageDataToExplicitStructuredGridType' )

#--------------------------------------------------------------
class VTKImageDataToHyperTreeGrid(Node, BVTK_Node):

    bl_idname = 'VTKImageDataToHyperTreeGridType'
    bl_label  = 'vtkImageDataToHyperTreeGrid'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DepthMax: bpy.props.IntProperty(name='DepthMax', default=0, update=BVTK_Node.outdate_vtk_status)
    m_NbColors: bpy.props.IntProperty(name='NbColors', default=256, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=3, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_DepthMax','m_NbColors',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageDataToHyperTreeGrid )        
TYPENAMES.append('VTKImageDataToHyperTreeGridType' )

#--------------------------------------------------------------
class VTKImageDataToPointSet(Node, BVTK_Node):

    bl_idname = 'VTKImageDataToPointSetType'
    bl_label  = 'vtkImageDataToPointSet'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageDataToPointSet )        
TYPENAMES.append('VTKImageDataToPointSetType' )

#--------------------------------------------------------------
class VTKImageDataToUniformGrid(Node, BVTK_Node):

    bl_idname = 'VTKImageDataToUniformGridType'
    bl_label  = 'vtkImageDataToUniformGrid'
    
    m_Reverse: bpy.props.BoolProperty(name='Reverse', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_Reverse','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageDataToUniformGrid )        
TYPENAMES.append('VTKImageDataToUniformGridType' )

#--------------------------------------------------------------
class VTKImageDilateErode3D(Node, BVTK_Node):

    bl_idname = 'VTKImageDilateErode3DType'
    bl_label  = 'vtkImageDilateErode3D'
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    m_DilateValue: bpy.props.FloatProperty(name='DilateValue', default=0.0, update=BVTK_Node.outdate_vtk_status)
    m_ErodeValue: bpy.props.FloatProperty(name='ErodeValue', default=255.0, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_KernelSize: bpy.props.IntVectorProperty(name='KernelSize', default=[1, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=10, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_EnableSMP','m_GlobalDefaultEnableSMP','m_ObjectName','m_DesiredBytesPerPiece','m_NumberOfThreads','m_DilateValue','m_ErodeValue','e_SplitMode','m_KernelSize','m_MinimumPieceSize',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageDilateErode3D )        
TYPENAMES.append('VTKImageDilateErode3DType' )

#--------------------------------------------------------------
class VTKImageDivergence(Node, BVTK_Node):

    bl_idname = 'VTKImageDivergenceType'
    bl_label  = 'vtkImageDivergence'
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=7, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_EnableSMP','m_GlobalDefaultEnableSMP','m_ObjectName','m_DesiredBytesPerPiece','m_NumberOfThreads','e_SplitMode','m_MinimumPieceSize',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageDivergence )        
TYPENAMES.append('VTKImageDivergenceType' )

#--------------------------------------------------------------
class VTKImageEuclideanDistance(Node, BVTK_Node):

    bl_idname = 'VTKImageEuclideanDistanceType'
    bl_label  = 'vtkImageEuclideanDistance'
    e_Algorithm_items=[ (x,x,x) for x in ['SaitoCached', 'Saito']]
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_ConsiderAnisotropy: bpy.props.BoolProperty(name='ConsiderAnisotropy', default=True, update=BVTK_Node.outdate_vtk_status)
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_Initialize: bpy.props.BoolProperty(name='Initialize', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_Dimensionality: bpy.props.IntProperty(name='Dimensionality', default=3, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    m_MaximumDistance: bpy.props.FloatProperty(name='MaximumDistance', default=2147483647.0, update=BVTK_Node.outdate_vtk_status)
    e_Algorithm: bpy.props.EnumProperty(name='Algorithm', default="Saito", items=e_Algorithm_items, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=12, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ConsiderAnisotropy','m_EnableSMP','m_GlobalDefaultEnableSMP','m_Initialize','m_ObjectName','m_DesiredBytesPerPiece','m_Dimensionality','m_NumberOfThreads','m_MaximumDistance','e_Algorithm','e_SplitMode','m_MinimumPieceSize',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageEuclideanDistance )        
TYPENAMES.append('VTKImageEuclideanDistanceType' )

#--------------------------------------------------------------
class VTKImageEuclideanToPolar(Node, BVTK_Node):

    bl_idname = 'VTKImageEuclideanToPolarType'
    bl_label  = 'vtkImageEuclideanToPolar'
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    m_ThetaMaximum: bpy.props.FloatProperty(name='ThetaMaximum', default=255.0, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=8, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_EnableSMP','m_GlobalDefaultEnableSMP','m_ObjectName','m_DesiredBytesPerPiece','m_NumberOfThreads','m_ThetaMaximum','e_SplitMode','m_MinimumPieceSize',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageEuclideanToPolar )        
TYPENAMES.append('VTKImageEuclideanToPolarType' )

#--------------------------------------------------------------
class VTKImageExtractComponents(Node, BVTK_Node):

    bl_idname = 'VTKImageExtractComponentsType'
    bl_label  = 'vtkImageExtractComponents'
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=7, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_EnableSMP','m_GlobalDefaultEnableSMP','m_ObjectName','m_DesiredBytesPerPiece','m_NumberOfThreads','e_SplitMode','m_MinimumPieceSize',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageExtractComponents )        
TYPENAMES.append('VTKImageExtractComponentsType' )

#--------------------------------------------------------------
class VTKImageFFT(Node, BVTK_Node):

    bl_idname = 'VTKImageFFTType'
    bl_label  = 'vtkImageFFT'
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_Dimensionality: bpy.props.IntProperty(name='Dimensionality', default=3, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=8, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_EnableSMP','m_GlobalDefaultEnableSMP','m_ObjectName','m_DesiredBytesPerPiece','m_Dimensionality','m_NumberOfThreads','e_SplitMode','m_MinimumPieceSize',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageFFT )        
TYPENAMES.append('VTKImageFFTType' )

#--------------------------------------------------------------
class VTKImageFourierCenter(Node, BVTK_Node):

    bl_idname = 'VTKImageFourierCenterType'
    bl_label  = 'vtkImageFourierCenter'
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_Dimensionality: bpy.props.IntProperty(name='Dimensionality', default=3, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=8, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_EnableSMP','m_GlobalDefaultEnableSMP','m_ObjectName','m_DesiredBytesPerPiece','m_Dimensionality','m_NumberOfThreads','e_SplitMode','m_MinimumPieceSize',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageFourierCenter )        
TYPENAMES.append('VTKImageFourierCenterType' )

#--------------------------------------------------------------
class VTKImageGaussianSmooth(Node, BVTK_Node):

    bl_idname = 'VTKImageGaussianSmoothType'
    bl_label  = 'vtkImageGaussianSmooth'
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_Dimensionality: bpy.props.IntProperty(name='Dimensionality', default=3, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    m_RadiusFactors: bpy.props.FloatVectorProperty(name='RadiusFactors', default=[1.5, 1.5, 1.5], size=3, update=BVTK_Node.outdate_vtk_status)
    m_StandardDeviations: bpy.props.FloatVectorProperty(name='StandardDeviations', default=[2.0, 2.0, 2.0], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=10, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_EnableSMP','m_GlobalDefaultEnableSMP','m_ObjectName','m_DesiredBytesPerPiece','m_Dimensionality','m_NumberOfThreads','e_SplitMode','m_MinimumPieceSize','m_RadiusFactors','m_StandardDeviations',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageGaussianSmooth )        
TYPENAMES.append('VTKImageGaussianSmoothType' )

#--------------------------------------------------------------
class VTKImageGradient(Node, BVTK_Node):

    bl_idname = 'VTKImageGradientType'
    bl_label  = 'vtkImageGradient'
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_HandleBoundaries: bpy.props.BoolProperty(name='HandleBoundaries', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_Dimensionality: bpy.props.IntProperty(name='Dimensionality', default=2, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=9, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_EnableSMP','m_GlobalDefaultEnableSMP','m_HandleBoundaries','m_ObjectName','m_DesiredBytesPerPiece','m_Dimensionality','m_NumberOfThreads','e_SplitMode','m_MinimumPieceSize',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageGradient )        
TYPENAMES.append('VTKImageGradientType' )

#--------------------------------------------------------------
class VTKImageGradientMagnitude(Node, BVTK_Node):

    bl_idname = 'VTKImageGradientMagnitudeType'
    bl_label  = 'vtkImageGradientMagnitude'
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_HandleBoundaries: bpy.props.BoolProperty(name='HandleBoundaries', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_Dimensionality: bpy.props.IntProperty(name='Dimensionality', default=2, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=9, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_EnableSMP','m_GlobalDefaultEnableSMP','m_HandleBoundaries','m_ObjectName','m_DesiredBytesPerPiece','m_Dimensionality','m_NumberOfThreads','e_SplitMode','m_MinimumPieceSize',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageGradientMagnitude )        
TYPENAMES.append('VTKImageGradientMagnitudeType' )

#--------------------------------------------------------------
class VTKImageHSIToRGB(Node, BVTK_Node):

    bl_idname = 'VTKImageHSIToRGBType'
    bl_label  = 'vtkImageHSIToRGB'
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    m_Maximum: bpy.props.FloatProperty(name='Maximum', default=255.0, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=8, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_EnableSMP','m_GlobalDefaultEnableSMP','m_ObjectName','m_DesiredBytesPerPiece','m_NumberOfThreads','m_Maximum','e_SplitMode','m_MinimumPieceSize',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageHSIToRGB )        
TYPENAMES.append('VTKImageHSIToRGBType' )

#--------------------------------------------------------------
class VTKImageHSVToRGB(Node, BVTK_Node):

    bl_idname = 'VTKImageHSVToRGBType'
    bl_label  = 'vtkImageHSVToRGB'
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    m_Maximum: bpy.props.FloatProperty(name='Maximum', default=255.0, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=8, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_EnableSMP','m_GlobalDefaultEnableSMP','m_ObjectName','m_DesiredBytesPerPiece','m_NumberOfThreads','m_Maximum','e_SplitMode','m_MinimumPieceSize',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageHSVToRGB )        
TYPENAMES.append('VTKImageHSVToRGBType' )

#--------------------------------------------------------------
class VTKImageHybridMedian2D(Node, BVTK_Node):

    bl_idname = 'VTKImageHybridMedian2DType'
    bl_label  = 'vtkImageHybridMedian2D'
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=7, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_EnableSMP','m_GlobalDefaultEnableSMP','m_ObjectName','m_DesiredBytesPerPiece','m_NumberOfThreads','e_SplitMode','m_MinimumPieceSize',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageHybridMedian2D )        
TYPENAMES.append('VTKImageHybridMedian2DType' )

#--------------------------------------------------------------
class VTKImageIdealHighPass(Node, BVTK_Node):

    bl_idname = 'VTKImageIdealHighPassType'
    bl_label  = 'vtkImageIdealHighPass'
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    m_XCutOff: bpy.props.FloatProperty(name='XCutOff', default=1e+30, update=BVTK_Node.outdate_vtk_status)
    m_YCutOff: bpy.props.FloatProperty(name='YCutOff', default=1e+30, update=BVTK_Node.outdate_vtk_status)
    m_ZCutOff: bpy.props.FloatProperty(name='ZCutOff', default=1e+30, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    m_CutOff: bpy.props.FloatVectorProperty(name='CutOff', default=[1e+30, 1e+30, 1e+30], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=11, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_EnableSMP','m_GlobalDefaultEnableSMP','m_ObjectName','m_DesiredBytesPerPiece','m_NumberOfThreads','m_XCutOff','m_YCutOff','m_ZCutOff','e_SplitMode','m_MinimumPieceSize','m_CutOff',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageIdealHighPass )        
TYPENAMES.append('VTKImageIdealHighPassType' )

#--------------------------------------------------------------
class VTKImageIdealLowPass(Node, BVTK_Node):

    bl_idname = 'VTKImageIdealLowPassType'
    bl_label  = 'vtkImageIdealLowPass'
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    m_XCutOff: bpy.props.FloatProperty(name='XCutOff', default=1e+30, update=BVTK_Node.outdate_vtk_status)
    m_YCutOff: bpy.props.FloatProperty(name='YCutOff', default=1e+30, update=BVTK_Node.outdate_vtk_status)
    m_ZCutOff: bpy.props.FloatProperty(name='ZCutOff', default=1e+30, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    m_CutOff: bpy.props.FloatVectorProperty(name='CutOff', default=[1e+30, 1e+30, 1e+30], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=11, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_EnableSMP','m_GlobalDefaultEnableSMP','m_ObjectName','m_DesiredBytesPerPiece','m_NumberOfThreads','m_XCutOff','m_YCutOff','m_ZCutOff','e_SplitMode','m_MinimumPieceSize','m_CutOff',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageIdealLowPass )        
TYPENAMES.append('VTKImageIdealLowPassType' )

#--------------------------------------------------------------
class VTKImageIslandRemoval2D(Node, BVTK_Node):

    bl_idname = 'VTKImageIslandRemoval2DType'
    bl_label  = 'vtkImageIslandRemoval2D'
    
    m_SquareNeighborhood: bpy.props.BoolProperty(name='SquareNeighborhood', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_AreaThreshold: bpy.props.IntProperty(name='AreaThreshold', default=4, update=BVTK_Node.outdate_vtk_status)
    m_IslandValue: bpy.props.FloatProperty(name='IslandValue', default=0.0, update=BVTK_Node.outdate_vtk_status)
    m_ReplaceValue: bpy.props.FloatProperty(name='ReplaceValue', default=255.0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=5, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_SquareNeighborhood','m_ObjectName','m_AreaThreshold','m_IslandValue','m_ReplaceValue',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageIslandRemoval2D )        
TYPENAMES.append('VTKImageIslandRemoval2DType' )

#--------------------------------------------------------------
class VTKImageLaplacian(Node, BVTK_Node):

    bl_idname = 'VTKImageLaplacianType'
    bl_label  = 'vtkImageLaplacian'
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_Dimensionality: bpy.props.IntProperty(name='Dimensionality', default=2, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=8, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_EnableSMP','m_GlobalDefaultEnableSMP','m_ObjectName','m_DesiredBytesPerPiece','m_Dimensionality','m_NumberOfThreads','e_SplitMode','m_MinimumPieceSize',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageLaplacian )        
TYPENAMES.append('VTKImageLaplacianType' )

#--------------------------------------------------------------
class VTKImageLogarithmicScale(Node, BVTK_Node):

    bl_idname = 'VTKImageLogarithmicScaleType'
    bl_label  = 'vtkImageLogarithmicScale'
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    m_Constant: bpy.props.FloatProperty(name='Constant', default=10.0, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=8, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_EnableSMP','m_GlobalDefaultEnableSMP','m_ObjectName','m_DesiredBytesPerPiece','m_NumberOfThreads','m_Constant','e_SplitMode','m_MinimumPieceSize',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageLogarithmicScale )        
TYPENAMES.append('VTKImageLogarithmicScaleType' )

#--------------------------------------------------------------
class VTKImageLuminance(Node, BVTK_Node):

    bl_idname = 'VTKImageLuminanceType'
    bl_label  = 'vtkImageLuminance'
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=7, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_EnableSMP','m_GlobalDefaultEnableSMP','m_ObjectName','m_DesiredBytesPerPiece','m_NumberOfThreads','e_SplitMode','m_MinimumPieceSize',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageLuminance )        
TYPENAMES.append('VTKImageLuminanceType' )

#--------------------------------------------------------------
class VTKImageMagnify(Node, BVTK_Node):

    bl_idname = 'VTKImageMagnifyType'
    bl_label  = 'vtkImageMagnify'
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_Interpolate: bpy.props.BoolProperty(name='Interpolate', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_MagnificationFactors: bpy.props.IntVectorProperty(name='MagnificationFactors', default=[1, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=9, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_EnableSMP','m_GlobalDefaultEnableSMP','m_Interpolate','m_ObjectName','m_DesiredBytesPerPiece','m_NumberOfThreads','e_SplitMode','m_MagnificationFactors','m_MinimumPieceSize',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageMagnify )        
TYPENAMES.append('VTKImageMagnifyType' )

#--------------------------------------------------------------
class VTKImageMagnitude(Node, BVTK_Node):

    bl_idname = 'VTKImageMagnitudeType'
    bl_label  = 'vtkImageMagnitude'
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=7, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_EnableSMP','m_GlobalDefaultEnableSMP','m_ObjectName','m_DesiredBytesPerPiece','m_NumberOfThreads','e_SplitMode','m_MinimumPieceSize',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageMagnitude )        
TYPENAMES.append('VTKImageMagnitudeType' )

#--------------------------------------------------------------
class VTKImageMapToColors(Node, BVTK_Node):

    bl_idname = 'VTKImageMapToColorsType'
    bl_label  = 'vtkImageMapToColors'
    e_OutputFormat_items=[ (x,x,x) for x in ['Luminance', 'LuminanceAlpha', 'RGB', 'RGBA']]
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_PassAlphaToOutput: bpy.props.BoolProperty(name='PassAlphaToOutput', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_ActiveComponent: bpy.props.IntProperty(name='ActiveComponent', default=0, update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    e_OutputFormat: bpy.props.EnumProperty(name='OutputFormat', default="RGBA", items=e_OutputFormat_items, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    m_NaNColor: bpy.props.IntVectorProperty(name='NaNColor', default=[0, 0, 0, 0], size=4, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=11, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_EnableSMP','m_GlobalDefaultEnableSMP','m_PassAlphaToOutput','m_ObjectName','m_ActiveComponent','m_DesiredBytesPerPiece','m_NumberOfThreads','e_OutputFormat','e_SplitMode','m_MinimumPieceSize','m_NaNColor',]
    def m_connections( self ):
        return (['input'], ['output'], ['LookupTable'], []) 
    
add_class( VTKImageMapToColors )        
TYPENAMES.append('VTKImageMapToColorsType' )

#--------------------------------------------------------------
class VTKImageMapToRGBA(Node, BVTK_Node):

    bl_idname = 'VTKImageMapToRGBAType'
    bl_label  = 'vtkImageMapToRGBA'
    e_OutputFormat_items=[ (x,x,x) for x in ['Luminance', 'LuminanceAlpha', 'RGB', 'RGBA']]
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_PassAlphaToOutput: bpy.props.BoolProperty(name='PassAlphaToOutput', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_ActiveComponent: bpy.props.IntProperty(name='ActiveComponent', default=0, update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    e_OutputFormat: bpy.props.EnumProperty(name='OutputFormat', default="RGBA", items=e_OutputFormat_items, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    m_NaNColor: bpy.props.IntVectorProperty(name='NaNColor', default=[0, 0, 0, 0], size=4, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=11, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_EnableSMP','m_GlobalDefaultEnableSMP','m_PassAlphaToOutput','m_ObjectName','m_ActiveComponent','m_DesiredBytesPerPiece','m_NumberOfThreads','e_OutputFormat','e_SplitMode','m_MinimumPieceSize','m_NaNColor',]
    def m_connections( self ):
        return (['input'], ['output'], ['LookupTable'], []) 
    
add_class( VTKImageMapToRGBA )        
TYPENAMES.append('VTKImageMapToRGBAType' )

#--------------------------------------------------------------
class VTKImageMapToWindowLevelColors(Node, BVTK_Node):

    bl_idname = 'VTKImageMapToWindowLevelColorsType'
    bl_label  = 'vtkImageMapToWindowLevelColors'
    e_OutputFormat_items=[ (x,x,x) for x in ['Luminance', 'LuminanceAlpha', 'RGB', 'RGBA']]
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_PassAlphaToOutput: bpy.props.BoolProperty(name='PassAlphaToOutput', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_ActiveComponent: bpy.props.IntProperty(name='ActiveComponent', default=0, update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    m_Level: bpy.props.FloatProperty(name='Level', default=127.5, update=BVTK_Node.outdate_vtk_status)
    m_Window: bpy.props.FloatProperty(name='Window', default=255.0, update=BVTK_Node.outdate_vtk_status)
    e_OutputFormat: bpy.props.EnumProperty(name='OutputFormat', default="RGBA", items=e_OutputFormat_items, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    m_NaNColor: bpy.props.IntVectorProperty(name='NaNColor', default=[0, 0, 0, 0], size=4, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=13, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_EnableSMP','m_GlobalDefaultEnableSMP','m_PassAlphaToOutput','m_ObjectName','m_ActiveComponent','m_DesiredBytesPerPiece','m_NumberOfThreads','m_Level','m_Window','e_OutputFormat','e_SplitMode','m_MinimumPieceSize','m_NaNColor',]
    def m_connections( self ):
        return (['input'], ['output'], ['LookupTable'], []) 
    
add_class( VTKImageMapToWindowLevelColors )        
TYPENAMES.append('VTKImageMapToWindowLevelColorsType' )

#--------------------------------------------------------------
class VTKImageMarchingCubes(Node, BVTK_Node):

    bl_idname = 'VTKImageMarchingCubesType'
    bl_label  = 'vtkImageMarchingCubes'
    
    m_ComputeGradients: bpy.props.BoolProperty(name='ComputeGradients', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ComputeNormals: bpy.props.BoolProperty(name='ComputeNormals', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ComputeScalars: bpy.props.BoolProperty(name='ComputeScalars', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_InputMemoryLimit: bpy.props.IntProperty(name='InputMemoryLimit', default=10240, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfContours: bpy.props.IntProperty(name='NumberOfContours', default=1, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=6, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ComputeGradients','m_ComputeNormals','m_ComputeScalars','m_ObjectName','m_InputMemoryLimit','m_NumberOfContours',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageMarchingCubes )        
TYPENAMES.append('VTKImageMarchingCubesType' )

#--------------------------------------------------------------
class VTKImageMaskBits(Node, BVTK_Node):

    bl_idname = 'VTKImageMaskBitsType'
    bl_label  = 'vtkImageMaskBits'
    e_Operation_items=[ (x,x,x) for x in ['And', 'Or', 'Xor', 'Nand', 'Nor']]
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    e_Operation: bpy.props.EnumProperty(name='Operation', default="And", items=e_Operation_items, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_Masks: bpy.props.IntVectorProperty(name='Masks', default=[1000000000, 1000000000, 1000000000, 1000000000], size=4, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=9, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_EnableSMP','m_GlobalDefaultEnableSMP','m_ObjectName','m_DesiredBytesPerPiece','m_NumberOfThreads','e_Operation','e_SplitMode','m_Masks','m_MinimumPieceSize',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageMaskBits )        
TYPENAMES.append('VTKImageMaskBitsType' )

#--------------------------------------------------------------
class VTKImageMathematics(Node, BVTK_Node):

    bl_idname = 'VTKImageMathematicsType'
    bl_label  = 'vtkImageMathematics'
    e_Operation_items=[ (x,x,x) for x in ['Add', 'Subtract', 'Multiply', 'Divide', 'Invert', 'Sin', 'Cos', 'Exp', 'Log', 'AbsoluteValue', 'Square', 'SquareRoot', 'Min', 'Max', 'ATAN', 'ATAN2', 'MultiplyByK', 'AddConstant', 'Conjugate', 'ComplexMultiply', 'ReplaceCByK']]
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_DivideByZeroToC: bpy.props.BoolProperty(name='DivideByZeroToC', default=True, update=BVTK_Node.outdate_vtk_status)
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    m_ConstantC: bpy.props.FloatProperty(name='ConstantC', default=0.0, update=BVTK_Node.outdate_vtk_status)
    m_ConstantK: bpy.props.FloatProperty(name='ConstantK', default=1.0, update=BVTK_Node.outdate_vtk_status)
    e_Operation: bpy.props.EnumProperty(name='Operation', default="Add", items=e_Operation_items, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=11, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_DivideByZeroToC','m_EnableSMP','m_GlobalDefaultEnableSMP','m_ObjectName','m_DesiredBytesPerPiece','m_NumberOfThreads','m_ConstantC','m_ConstantK','e_Operation','e_SplitMode','m_MinimumPieceSize',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageMathematics )        
TYPENAMES.append('VTKImageMathematicsType' )

#--------------------------------------------------------------
class VTKImageMedian3D(Node, BVTK_Node):

    bl_idname = 'VTKImageMedian3DType'
    bl_label  = 'vtkImageMedian3D'
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_KernelSize: bpy.props.IntVectorProperty(name='KernelSize', default=[1, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=8, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_EnableSMP','m_GlobalDefaultEnableSMP','m_ObjectName','m_DesiredBytesPerPiece','m_NumberOfThreads','e_SplitMode','m_KernelSize','m_MinimumPieceSize',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageMedian3D )        
TYPENAMES.append('VTKImageMedian3DType' )

#--------------------------------------------------------------
class VTKImageMirrorPad(Node, BVTK_Node):

    bl_idname = 'VTKImageMirrorPadType'
    bl_label  = 'vtkImageMirrorPad'
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    m_OutputNumberOfScalarComponents: bpy.props.IntProperty(name='OutputNumberOfScalarComponents', default=-1, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=8, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_EnableSMP','m_GlobalDefaultEnableSMP','m_ObjectName','m_DesiredBytesPerPiece','m_NumberOfThreads','m_OutputNumberOfScalarComponents','e_SplitMode','m_MinimumPieceSize',]
    def m_connections( self ):
        return (['input'], ['output'], ['OutputWholeExtent'], []) 
    
add_class( VTKImageMirrorPad )        
TYPENAMES.append('VTKImageMirrorPadType' )

#--------------------------------------------------------------
class VTKImageNormalize(Node, BVTK_Node):

    bl_idname = 'VTKImageNormalizeType'
    bl_label  = 'vtkImageNormalize'
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=7, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_EnableSMP','m_GlobalDefaultEnableSMP','m_ObjectName','m_DesiredBytesPerPiece','m_NumberOfThreads','e_SplitMode','m_MinimumPieceSize',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageNormalize )        
TYPENAMES.append('VTKImageNormalizeType' )

#--------------------------------------------------------------
class VTKImageOpenClose3D(Node, BVTK_Node):

    bl_idname = 'VTKImageOpenClose3DType'
    bl_label  = 'vtkImageOpenClose3D'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_CloseValue: bpy.props.FloatProperty(name='CloseValue', default=255.0, update=BVTK_Node.outdate_vtk_status)
    m_OpenValue: bpy.props.FloatProperty(name='OpenValue', default=0.0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=3, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_CloseValue','m_OpenValue',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageOpenClose3D )        
TYPENAMES.append('VTKImageOpenClose3DType' )

#--------------------------------------------------------------
class VTKImagePadFilter(Node, BVTK_Node):

    bl_idname = 'VTKImagePadFilterType'
    bl_label  = 'vtkImagePadFilter'
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    m_OutputNumberOfScalarComponents: bpy.props.IntProperty(name='OutputNumberOfScalarComponents', default=-1, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=8, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_EnableSMP','m_GlobalDefaultEnableSMP','m_ObjectName','m_DesiredBytesPerPiece','m_NumberOfThreads','m_OutputNumberOfScalarComponents','e_SplitMode','m_MinimumPieceSize',]
    def m_connections( self ):
        return (['input'], ['output'], ['OutputWholeExtent'], []) 
    
add_class( VTKImagePadFilter )        
TYPENAMES.append('VTKImagePadFilterType' )

#--------------------------------------------------------------
class VTKImageQuantizeRGBToIndex(Node, BVTK_Node):

    bl_idname = 'VTKImageQuantizeRGBToIndexType'
    bl_label  = 'vtkImageQuantizeRGBToIndex'
    
    m_SortIndexByLuminance: bpy.props.BoolProperty(name='SortIndexByLuminance', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_NumberOfColors: bpy.props.IntProperty(name='NumberOfColors', default=256, update=BVTK_Node.outdate_vtk_status)
    m_BuildTreeExecuteTime: bpy.props.FloatProperty(name='BuildTreeExecuteTime', default=0.0, update=BVTK_Node.outdate_vtk_status)
    m_InitializeExecuteTime: bpy.props.FloatProperty(name='InitializeExecuteTime', default=0.0, update=BVTK_Node.outdate_vtk_status)
    m_LookupIndexExecuteTime: bpy.props.FloatProperty(name='LookupIndexExecuteTime', default=0.0, update=BVTK_Node.outdate_vtk_status)
    m_SamplingRate: bpy.props.IntVectorProperty(name='SamplingRate', default=[1, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=7, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_SortIndexByLuminance','m_ObjectName','m_NumberOfColors','m_BuildTreeExecuteTime','m_InitializeExecuteTime','m_LookupIndexExecuteTime','m_SamplingRate',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageQuantizeRGBToIndex )        
TYPENAMES.append('VTKImageQuantizeRGBToIndexType' )

#--------------------------------------------------------------
class VTKImageRFFT(Node, BVTK_Node):

    bl_idname = 'VTKImageRFFTType'
    bl_label  = 'vtkImageRFFT'
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_Dimensionality: bpy.props.IntProperty(name='Dimensionality', default=3, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=8, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_EnableSMP','m_GlobalDefaultEnableSMP','m_ObjectName','m_DesiredBytesPerPiece','m_Dimensionality','m_NumberOfThreads','e_SplitMode','m_MinimumPieceSize',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageRFFT )        
TYPENAMES.append('VTKImageRFFTType' )

#--------------------------------------------------------------
class VTKImageRGBToHSI(Node, BVTK_Node):

    bl_idname = 'VTKImageRGBToHSIType'
    bl_label  = 'vtkImageRGBToHSI'
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    m_Maximum: bpy.props.FloatProperty(name='Maximum', default=255.0, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=8, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_EnableSMP','m_GlobalDefaultEnableSMP','m_ObjectName','m_DesiredBytesPerPiece','m_NumberOfThreads','m_Maximum','e_SplitMode','m_MinimumPieceSize',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageRGBToHSI )        
TYPENAMES.append('VTKImageRGBToHSIType' )

#--------------------------------------------------------------
class VTKImageRGBToHSV(Node, BVTK_Node):

    bl_idname = 'VTKImageRGBToHSVType'
    bl_label  = 'vtkImageRGBToHSV'
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    m_Maximum: bpy.props.FloatProperty(name='Maximum', default=255.0, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=8, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_EnableSMP','m_GlobalDefaultEnableSMP','m_ObjectName','m_DesiredBytesPerPiece','m_NumberOfThreads','m_Maximum','e_SplitMode','m_MinimumPieceSize',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageRGBToHSV )        
TYPENAMES.append('VTKImageRGBToHSVType' )

#--------------------------------------------------------------
class VTKImageRGBToYIQ(Node, BVTK_Node):

    bl_idname = 'VTKImageRGBToYIQType'
    bl_label  = 'vtkImageRGBToYIQ'
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    m_Maximum: bpy.props.FloatProperty(name='Maximum', default=255.0, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=8, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_EnableSMP','m_GlobalDefaultEnableSMP','m_ObjectName','m_DesiredBytesPerPiece','m_NumberOfThreads','m_Maximum','e_SplitMode','m_MinimumPieceSize',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageRGBToYIQ )        
TYPENAMES.append('VTKImageRGBToYIQType' )

#--------------------------------------------------------------
class VTKImageRange3D(Node, BVTK_Node):

    bl_idname = 'VTKImageRange3DType'
    bl_label  = 'vtkImageRange3D'
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_KernelSize: bpy.props.IntVectorProperty(name='KernelSize', default=[1, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=8, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_EnableSMP','m_GlobalDefaultEnableSMP','m_ObjectName','m_DesiredBytesPerPiece','m_NumberOfThreads','e_SplitMode','m_KernelSize','m_MinimumPieceSize',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageRange3D )        
TYPENAMES.append('VTKImageRange3DType' )

#--------------------------------------------------------------
class VTKImageResize(Node, BVTK_Node):

    bl_idname = 'VTKImageResizeType'
    bl_label  = 'vtkImageResize'
    e_ResizeMethod_items=[ (x,x,x) for x in ['OutputDimensions', 'OutputSpacing', 'MagnificationFactors']]
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_Border: bpy.props.BoolProperty(name='Border', default=True, update=BVTK_Node.outdate_vtk_status)
    m_Cropping: bpy.props.BoolProperty(name='Cropping', default=True, update=BVTK_Node.outdate_vtk_status)
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_Interpolate: bpy.props.BoolProperty(name='Interpolate', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=0, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    e_ResizeMethod: bpy.props.EnumProperty(name='ResizeMethod', default="OutputDimensions", items=e_ResizeMethod_items, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    m_OutputDimensions: bpy.props.IntVectorProperty(name='OutputDimensions', default=[-1, -1, -1], size=3, update=BVTK_Node.outdate_vtk_status)
    m_MagnificationFactors: bpy.props.FloatVectorProperty(name='MagnificationFactors', default=[1.0, 1.0, 1.0], size=3, update=BVTK_Node.outdate_vtk_status)
    m_OutputSpacing: bpy.props.FloatVectorProperty(name='OutputSpacing', default=[0.0, 0.0, 0.0], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=14, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_Border','m_Cropping','m_EnableSMP','m_GlobalDefaultEnableSMP','m_Interpolate','m_ObjectName','m_DesiredBytesPerPiece','m_NumberOfThreads','e_ResizeMethod','e_SplitMode','m_MinimumPieceSize','m_OutputDimensions','m_MagnificationFactors','m_OutputSpacing',]
    def m_connections( self ):
        return (['input'], ['output'], ['Interpolator'], []) 
    
add_class( VTKImageResize )        
TYPENAMES.append('VTKImageResizeType' )

#--------------------------------------------------------------
class VTKImageSeedConnectivity(Node, BVTK_Node):

    bl_idname = 'VTKImageSeedConnectivityType'
    bl_label  = 'vtkImageSeedConnectivity'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_Dimensionality: bpy.props.IntProperty(name='Dimensionality', default=3, update=BVTK_Node.outdate_vtk_status)
    m_InputConnectValue: bpy.props.IntProperty(name='InputConnectValue', default=255, update=BVTK_Node.outdate_vtk_status)
    m_OutputConnectedValue: bpy.props.IntProperty(name='OutputConnectedValue', default=255, update=BVTK_Node.outdate_vtk_status)
    m_OutputUnconnectedValue: bpy.props.IntProperty(name='OutputUnconnectedValue', default=0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=5, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_Dimensionality','m_InputConnectValue','m_OutputConnectedValue','m_OutputUnconnectedValue',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageSeedConnectivity )        
TYPENAMES.append('VTKImageSeedConnectivityType' )

#--------------------------------------------------------------
class VTKImageSeparableConvolution(Node, BVTK_Node):

    bl_idname = 'VTKImageSeparableConvolutionType'
    bl_label  = 'vtkImageSeparableConvolution'
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_Dimensionality: bpy.props.IntProperty(name='Dimensionality', default=3, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=8, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_EnableSMP','m_GlobalDefaultEnableSMP','m_ObjectName','m_DesiredBytesPerPiece','m_Dimensionality','m_NumberOfThreads','e_SplitMode','m_MinimumPieceSize',]
    def m_connections( self ):
        return (['input'], ['output'], ['XKernel', 'YKernel', 'ZKernel'], []) 
    
add_class( VTKImageSeparableConvolution )        
TYPENAMES.append('VTKImageSeparableConvolutionType' )

#--------------------------------------------------------------
class VTKImageShiftScale(Node, BVTK_Node):

    bl_idname = 'VTKImageShiftScaleType'
    bl_label  = 'vtkImageShiftScale'
    e_OutputScalarType_items=[ (x,x,x) for x in ['Char', 'UnsignedChar', 'Short', 'UnsignedShort', 'Int', 'UnsignedInt', 'Long', 'UnsignedLong', 'Float', 'Double']]
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_ClampOverflow: bpy.props.BoolProperty(name='ClampOverflow', default=True, update=BVTK_Node.outdate_vtk_status)
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    m_Scale: bpy.props.FloatProperty(name='Scale', default=1.0, update=BVTK_Node.outdate_vtk_status)
    m_Shift: bpy.props.FloatProperty(name='Shift', default=0.0, update=BVTK_Node.outdate_vtk_status)
    e_OutputScalarType: bpy.props.EnumProperty(name='OutputScalarType', default="Char", items=e_OutputScalarType_items, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=11, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ClampOverflow','m_EnableSMP','m_GlobalDefaultEnableSMP','m_ObjectName','m_DesiredBytesPerPiece','m_NumberOfThreads','m_Scale','m_Shift','e_OutputScalarType','e_SplitMode','m_MinimumPieceSize',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageShiftScale )        
TYPENAMES.append('VTKImageShiftScaleType' )

#--------------------------------------------------------------
class VTKImageShrink3D(Node, BVTK_Node):

    bl_idname = 'VTKImageShrink3DType'
    bl_label  = 'vtkImageShrink3D'
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_Averaging: bpy.props.BoolProperty(name='Averaging', default=True, update=BVTK_Node.outdate_vtk_status)
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_Maximum: bpy.props.BoolProperty(name='Maximum', default=True, update=BVTK_Node.outdate_vtk_status)
    m_Mean: bpy.props.BoolProperty(name='Mean', default=True, update=BVTK_Node.outdate_vtk_status)
    m_Median: bpy.props.BoolProperty(name='Median', default=True, update=BVTK_Node.outdate_vtk_status)
    m_Minimum: bpy.props.BoolProperty(name='Minimum', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    m_Shift: bpy.props.IntVectorProperty(name='Shift', default=[0, 0, 0], size=3, update=BVTK_Node.outdate_vtk_status)
    m_ShrinkFactors: bpy.props.IntVectorProperty(name='ShrinkFactors', default=[1, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=14, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_Averaging','m_EnableSMP','m_GlobalDefaultEnableSMP','m_Maximum','m_Mean','m_Median','m_Minimum','m_ObjectName','m_DesiredBytesPerPiece','m_NumberOfThreads','e_SplitMode','m_MinimumPieceSize','m_Shift','m_ShrinkFactors',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageShrink3D )        
TYPENAMES.append('VTKImageShrink3DType' )

#--------------------------------------------------------------
class VTKImageSkeleton2D(Node, BVTK_Node):

    bl_idname = 'VTKImageSkeleton2DType'
    bl_label  = 'vtkImageSkeleton2D'
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_Prune: bpy.props.BoolProperty(name='Prune', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfIterations: bpy.props.IntProperty(name='NumberOfIterations', default=1, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=9, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_EnableSMP','m_GlobalDefaultEnableSMP','m_Prune','m_ObjectName','m_DesiredBytesPerPiece','m_NumberOfIterations','m_NumberOfThreads','e_SplitMode','m_MinimumPieceSize',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageSkeleton2D )        
TYPENAMES.append('VTKImageSkeleton2DType' )

#--------------------------------------------------------------
class VTKImageSlab(Node, BVTK_Node):

    bl_idname = 'VTKImageSlabType'
    bl_label  = 'vtkImageSlab'
    e_Operation_items=[ (x,x,x) for x in ['Min', 'Max', 'Mean', 'Sum']]
    e_Orientation_items=[ (x,x,x) for x in ['X', 'Y', 'Z']]
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_MultiSliceOutput: bpy.props.BoolProperty(name='MultiSliceOutput', default=True, update=BVTK_Node.outdate_vtk_status)
    m_TrapezoidIntegration: bpy.props.BoolProperty(name='TrapezoidIntegration', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    e_Operation: bpy.props.EnumProperty(name='Operation', default="Mean", items=e_Operation_items, update=BVTK_Node.outdate_vtk_status)
    e_Orientation: bpy.props.EnumProperty(name='Orientation', default="Z", items=e_Orientation_items, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    m_SliceRange: bpy.props.IntVectorProperty(name='SliceRange', default=[-1000000000, 1000000000], size=2, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=12, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_EnableSMP','m_GlobalDefaultEnableSMP','m_MultiSliceOutput','m_TrapezoidIntegration','m_ObjectName','m_DesiredBytesPerPiece','m_NumberOfThreads','e_Operation','e_Orientation','e_SplitMode','m_MinimumPieceSize','m_SliceRange',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageSlab )        
TYPENAMES.append('VTKImageSlabType' )

#--------------------------------------------------------------
class VTKImageSobel2D(Node, BVTK_Node):

    bl_idname = 'VTKImageSobel2DType'
    bl_label  = 'vtkImageSobel2D'
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=7, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_EnableSMP','m_GlobalDefaultEnableSMP','m_ObjectName','m_DesiredBytesPerPiece','m_NumberOfThreads','e_SplitMode','m_MinimumPieceSize',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageSobel2D )        
TYPENAMES.append('VTKImageSobel2DType' )

#--------------------------------------------------------------
class VTKImageSobel3D(Node, BVTK_Node):

    bl_idname = 'VTKImageSobel3DType'
    bl_label  = 'vtkImageSobel3D'
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=7, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_EnableSMP','m_GlobalDefaultEnableSMP','m_ObjectName','m_DesiredBytesPerPiece','m_NumberOfThreads','e_SplitMode','m_MinimumPieceSize',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageSobel3D )        
TYPENAMES.append('VTKImageSobel3DType' )

#--------------------------------------------------------------
class VTKImageSpatialAlgorithm(Node, BVTK_Node):

    bl_idname = 'VTKImageSpatialAlgorithmType'
    bl_label  = 'vtkImageSpatialAlgorithm'
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=7, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_EnableSMP','m_GlobalDefaultEnableSMP','m_ObjectName','m_DesiredBytesPerPiece','m_NumberOfThreads','e_SplitMode','m_MinimumPieceSize',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageSpatialAlgorithm )        
TYPENAMES.append('VTKImageSpatialAlgorithmType' )

#--------------------------------------------------------------
class VTKImageStencilAlgorithm(Node, BVTK_Node):

    bl_idname = 'VTKImageStencilAlgorithmType'
    bl_label  = 'vtkImageStencilAlgorithm'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageStencilAlgorithm )        
TYPENAMES.append('VTKImageStencilAlgorithmType' )

#--------------------------------------------------------------
class VTKImageStencilSource(Node, BVTK_Node):

    bl_idname = 'VTKImageStencilSourceType'
    bl_label  = 'vtkImageStencilSource'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_OutputWholeExtent: bpy.props.IntVectorProperty(name='OutputWholeExtent', default=[0, -1, 0, -1, 0, -1], size=6, update=BVTK_Node.outdate_vtk_status)
    m_OutputOrigin: bpy.props.FloatVectorProperty(name='OutputOrigin', default=[0.0, 0.0, 0.0], size=3, update=BVTK_Node.outdate_vtk_status)
    m_OutputSpacing: bpy.props.FloatVectorProperty(name='OutputSpacing', default=[1.0, 1.0, 1.0], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=4, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_OutputWholeExtent','m_OutputOrigin','m_OutputSpacing',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageStencilSource )        
TYPENAMES.append('VTKImageStencilSourceType' )

#--------------------------------------------------------------
class VTKImageStencilToImage(Node, BVTK_Node):

    bl_idname = 'VTKImageStencilToImageType'
    bl_label  = 'vtkImageStencilToImage'
    e_OutputScalarType_items=[ (x,x,x) for x in ['Char', 'UnsignedChar', 'Short', 'UnsignedShort', 'Int', 'UnsignedInt', 'Long', 'UnsignedLong', 'Float', 'Double']]
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_InsideValue: bpy.props.FloatProperty(name='InsideValue', default=1.0, update=BVTK_Node.outdate_vtk_status)
    m_OutsideValue: bpy.props.FloatProperty(name='OutsideValue', default=0.0, update=BVTK_Node.outdate_vtk_status)
    e_OutputScalarType: bpy.props.EnumProperty(name='OutputScalarType', default="UnsignedChar", items=e_OutputScalarType_items, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=4, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_InsideValue','m_OutsideValue','e_OutputScalarType',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageStencilToImage )        
TYPENAMES.append('VTKImageStencilToImageType' )

#--------------------------------------------------------------
class VTKImageThreshold(Node, BVTK_Node):

    bl_idname = 'VTKImageThresholdType'
    bl_label  = 'vtkImageThreshold'
    e_OutputScalarType_items=[ (x,x,x) for x in ['Char', 'UnsignedChar', 'Short', 'UnsignedShort', 'Int', 'UnsignedInt', 'Long', 'UnsignedLong', 'Float', 'Double', 'SignedChar']]
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ReplaceIn: bpy.props.BoolProperty(name='ReplaceIn', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ReplaceOut: bpy.props.BoolProperty(name='ReplaceOut', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    m_InValue: bpy.props.FloatProperty(name='InValue', default=0.0, update=BVTK_Node.outdate_vtk_status)
    m_OutValue: bpy.props.FloatProperty(name='OutValue', default=0.0, update=BVTK_Node.outdate_vtk_status)
    e_OutputScalarType: bpy.props.EnumProperty(name='OutputScalarType', default="Char", items=e_OutputScalarType_items, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=12, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_EnableSMP','m_GlobalDefaultEnableSMP','m_ReplaceIn','m_ReplaceOut','m_ObjectName','m_DesiredBytesPerPiece','m_NumberOfThreads','m_InValue','m_OutValue','e_OutputScalarType','e_SplitMode','m_MinimumPieceSize',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageThreshold )        
TYPENAMES.append('VTKImageThresholdType' )

#--------------------------------------------------------------
class VTKImageToAMR(Node, BVTK_Node):

    bl_idname = 'VTKImageToAMRType'
    bl_label  = 'vtkImageToAMR'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_MaximumNumberOfBlocks: bpy.props.IntProperty(name='MaximumNumberOfBlocks', default=100, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfLevels: bpy.props.IntProperty(name='NumberOfLevels', default=2, update=BVTK_Node.outdate_vtk_status)
    m_RefinementRatio: bpy.props.IntProperty(name='RefinementRatio', default=2, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=4, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_MaximumNumberOfBlocks','m_NumberOfLevels','m_RefinementRatio',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageToAMR )        
TYPENAMES.append('VTKImageToAMRType' )

#--------------------------------------------------------------
class VTKImageToImageStencil(Node, BVTK_Node):

    bl_idname = 'VTKImageToImageStencilType'
    bl_label  = 'vtkImageToImageStencil'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_LowerThreshold: bpy.props.FloatProperty(name='LowerThreshold', default=-1e+30, update=BVTK_Node.outdate_vtk_status)
    m_UpperThreshold: bpy.props.FloatProperty(name='UpperThreshold', default=1e+30, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=3, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_LowerThreshold','m_UpperThreshold',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageToImageStencil )        
TYPENAMES.append('VTKImageToImageStencilType' )

#--------------------------------------------------------------
class VTKImageToPolyDataFilter(Node, BVTK_Node):

    bl_idname = 'VTKImageToPolyDataFilterType'
    bl_label  = 'vtkImageToPolyDataFilter'
    e_ColorMode_items=[ (x,x,x) for x in ['LUT', 'Linear256']]
    e_OutputStyle_items=[ (x,x,x) for x in ['Pixelize', 'Polygonalize', 'RunLength']]
    
    m_Decimation: bpy.props.BoolProperty(name='Decimation', default=True, update=BVTK_Node.outdate_vtk_status)
    m_Smoothing: bpy.props.BoolProperty(name='Smoothing', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_Error: bpy.props.IntProperty(name='Error', default=100, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfSmoothingIterations: bpy.props.IntProperty(name='NumberOfSmoothingIterations', default=40, update=BVTK_Node.outdate_vtk_status)
    m_SubImageSize: bpy.props.IntProperty(name='SubImageSize', default=250, update=BVTK_Node.outdate_vtk_status)
    m_DecimationError: bpy.props.FloatProperty(name='DecimationError', default=1.5, update=BVTK_Node.outdate_vtk_status)
    e_ColorMode: bpy.props.EnumProperty(name='ColorMode', default="Linear256", items=e_ColorMode_items, update=BVTK_Node.outdate_vtk_status)
    e_OutputStyle: bpy.props.EnumProperty(name='OutputStyle', default="Polygonalize", items=e_OutputStyle_items, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=9, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_Decimation','m_Smoothing','m_ObjectName','m_Error','m_NumberOfSmoothingIterations','m_SubImageSize','m_DecimationError','e_ColorMode','e_OutputStyle',]
    def m_connections( self ):
        return (['input'], ['output'], ['LookupTable'], []) 
    
add_class( VTKImageToPolyDataFilter )        
TYPENAMES.append('VTKImageToPolyDataFilterType' )

#--------------------------------------------------------------
class VTKImageToStructuredGrid(Node, BVTK_Node):

    bl_idname = 'VTKImageToStructuredGridType'
    bl_label  = 'vtkImageToStructuredGrid'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageToStructuredGrid )        
TYPENAMES.append('VTKImageToStructuredGridType' )

#--------------------------------------------------------------
class VTKImageTranslateExtent(Node, BVTK_Node):

    bl_idname = 'VTKImageTranslateExtentType'
    bl_label  = 'vtkImageTranslateExtent'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_Translation: bpy.props.IntVectorProperty(name='Translation', default=[0, 0, 0], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_Translation',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageTranslateExtent )        
TYPENAMES.append('VTKImageTranslateExtentType' )

#--------------------------------------------------------------
class VTKImageVariance3D(Node, BVTK_Node):

    bl_idname = 'VTKImageVariance3DType'
    bl_label  = 'vtkImageVariance3D'
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_KernelSize: bpy.props.IntVectorProperty(name='KernelSize', default=[1, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=8, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_EnableSMP','m_GlobalDefaultEnableSMP','m_ObjectName','m_DesiredBytesPerPiece','m_NumberOfThreads','e_SplitMode','m_KernelSize','m_MinimumPieceSize',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageVariance3D )        
TYPENAMES.append('VTKImageVariance3DType' )

#--------------------------------------------------------------
class VTKImageWeightedSum(Node, BVTK_Node):

    bl_idname = 'VTKImageWeightedSumType'
    bl_label  = 'vtkImageWeightedSum'
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_NormalizeByWeight: bpy.props.BoolProperty(name='NormalizeByWeight', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=8, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_EnableSMP','m_GlobalDefaultEnableSMP','m_NormalizeByWeight','m_ObjectName','m_DesiredBytesPerPiece','m_NumberOfThreads','e_SplitMode','m_MinimumPieceSize',]
    def m_connections( self ):
        return (['input'], ['output'], ['Weights'], []) 
    
add_class( VTKImageWeightedSum )        
TYPENAMES.append('VTKImageWeightedSumType' )

#--------------------------------------------------------------
class VTKImageWrapPad(Node, BVTK_Node):

    bl_idname = 'VTKImageWrapPadType'
    bl_label  = 'vtkImageWrapPad'
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    m_OutputNumberOfScalarComponents: bpy.props.IntProperty(name='OutputNumberOfScalarComponents', default=-1, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=8, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_EnableSMP','m_GlobalDefaultEnableSMP','m_ObjectName','m_DesiredBytesPerPiece','m_NumberOfThreads','m_OutputNumberOfScalarComponents','e_SplitMode','m_MinimumPieceSize',]
    def m_connections( self ):
        return (['input'], ['output'], ['OutputWholeExtent'], []) 
    
add_class( VTKImageWrapPad )        
TYPENAMES.append('VTKImageWrapPadType' )

#--------------------------------------------------------------
class VTKImageYIQToRGB(Node, BVTK_Node):

    bl_idname = 'VTKImageYIQToRGBType'
    bl_label  = 'vtkImageYIQToRGB'
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    m_Maximum: bpy.props.FloatProperty(name='Maximum', default=255.0, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=8, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_EnableSMP','m_GlobalDefaultEnableSMP','m_ObjectName','m_DesiredBytesPerPiece','m_NumberOfThreads','m_Maximum','e_SplitMode','m_MinimumPieceSize',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImageYIQToRGB )        
TYPENAMES.append('VTKImageYIQToRGBType' )

#--------------------------------------------------------------
class VTKImplicitModeller(Node, BVTK_Node):

    bl_idname = 'VTKImplicitModellerType'
    bl_label  = 'vtkImplicitModeller'
    e_OutputScalarType_items=[ (x,x,x) for x in ['Char', 'UnsignedChar', 'Short', 'UnsignedShort', 'Int', 'UnsignedInt', 'Long', 'UnsignedLong', 'Float', 'Double']]
    e_ProcessMode_items=[ (x,x,x) for x in ['PerVoxel', 'PerCell']]
    
    m_AdjustBounds: bpy.props.BoolProperty(name='AdjustBounds', default=True, update=BVTK_Node.outdate_vtk_status)
    m_Capping: bpy.props.BoolProperty(name='Capping', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ScaleToMaximumDistance: bpy.props.BoolProperty(name='ScaleToMaximumDistance', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_LocatorMaxLevel: bpy.props.IntProperty(name='LocatorMaxLevel', default=5, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    m_AdjustDistance: bpy.props.FloatProperty(name='AdjustDistance', default=0.0125, update=BVTK_Node.outdate_vtk_status)
    m_CapValue: bpy.props.FloatProperty(name='CapValue', default=1e+30, update=BVTK_Node.outdate_vtk_status)
    m_MaximumDistance: bpy.props.FloatProperty(name='MaximumDistance', default=0.1, update=BVTK_Node.outdate_vtk_status)
    e_OutputScalarType: bpy.props.EnumProperty(name='OutputScalarType', default="Float", items=e_OutputScalarType_items, update=BVTK_Node.outdate_vtk_status)
    e_ProcessMode: bpy.props.EnumProperty(name='ProcessMode', default="PerCell", items=e_ProcessMode_items, update=BVTK_Node.outdate_vtk_status)
    m_SampleDimensions: bpy.props.IntVectorProperty(name='SampleDimensions', default=[50, 50, 50], size=3, update=BVTK_Node.outdate_vtk_status)
    m_ModelBounds: bpy.props.FloatVectorProperty(name='ModelBounds', default=[0.0, 0.0, 0.0, 0.0, 0.0, 0.0], size=6, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=13, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_AdjustBounds','m_Capping','m_ScaleToMaximumDistance','m_ObjectName','m_LocatorMaxLevel','m_NumberOfThreads','m_AdjustDistance','m_CapValue','m_MaximumDistance','e_OutputScalarType','e_ProcessMode','m_SampleDimensions','m_ModelBounds',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKImplicitModeller )        
TYPENAMES.append('VTKImplicitModellerType' )

#--------------------------------------------------------------
class VTKImplicitTextureCoords(Node, BVTK_Node):

    bl_idname = 'VTKImplicitTextureCoordsType'
    bl_label  = 'vtkImplicitTextureCoords'
    
    m_FlipTexture: bpy.props.BoolProperty(name='FlipTexture', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_FlipTexture','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], ['RFunction', 'SFunction', 'TFunction'], []) 
    
add_class( VTKImplicitTextureCoords )        
TYPENAMES.append('VTKImplicitTextureCoordsType' )

#--------------------------------------------------------------
class VTKIntegrateAttributes(Node, BVTK_Node):

    bl_idname = 'VTKIntegrateAttributesType'
    bl_label  = 'vtkIntegrateAttributes'
    
    m_DivideAllCellDataByVolume: bpy.props.BoolProperty(name='DivideAllCellDataByVolume', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_DivideAllCellDataByVolume','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKIntegrateAttributes )        
TYPENAMES.append('VTKIntegrateAttributesType' )

#--------------------------------------------------------------
class VTKInterpolateDataSetAttributes(Node, BVTK_Node):

    bl_idname = 'VTKInterpolateDataSetAttributesType'
    bl_label  = 'vtkInterpolateDataSetAttributes'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_T: bpy.props.FloatProperty(name='T', default=0.0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_T',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKInterpolateDataSetAttributes )        
TYPENAMES.append('VTKInterpolateDataSetAttributesType' )

#--------------------------------------------------------------
class VTKKdTreeSelector(Node, BVTK_Node):

    bl_idname = 'VTKKdTreeSelectorType'
    bl_label  = 'vtkKdTreeSelector'
    
    m_SingleSelection: bpy.props.BoolProperty(name='SingleSelection', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_SelectionFieldName: bpy.props.StringProperty(name='SelectionFieldName', default="", update=BVTK_Node.outdate_vtk_status)
    m_SelectionAttribute: bpy.props.IntProperty(name='SelectionAttribute', default=-1, update=BVTK_Node.outdate_vtk_status)
    m_SingleSelectionThreshold: bpy.props.FloatProperty(name='SingleSelectionThreshold', default=1.0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=5, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_SingleSelection','m_ObjectName','m_SelectionFieldName','m_SelectionAttribute','m_SingleSelectionThreshold',]
    def m_connections( self ):
        return (['input'], ['output'], ['KdTree'], []) 
    
add_class( VTKKdTreeSelector )        
TYPENAMES.append('VTKKdTreeSelectorType' )

#--------------------------------------------------------------
class VTKLabelHierarchyAlgorithm(Node, BVTK_Node):

    bl_idname = 'VTKLabelHierarchyAlgorithmType'
    bl_label  = 'vtkLabelHierarchyAlgorithm'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKLabelHierarchyAlgorithm )        
TYPENAMES.append('VTKLabelHierarchyAlgorithmType' )

#--------------------------------------------------------------
class VTKLabelSizeCalculator(Node, BVTK_Node):

    bl_idname = 'VTKLabelSizeCalculatorType'
    bl_label  = 'vtkLabelSizeCalculator'
    
    m_LabelSizeArrayName: bpy.props.StringProperty(name='LabelSizeArrayName', default="LabelSize", update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DPI: bpy.props.IntProperty(name='DPI', default=72, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=3, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_LabelSizeArrayName','m_ObjectName','m_DPI',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKLabelSizeCalculator )        
TYPENAMES.append('VTKLabelSizeCalculatorType' )

#--------------------------------------------------------------
class VTKLengthDistribution(Node, BVTK_Node):

    bl_idname = 'VTKLengthDistributionType'
    bl_label  = 'vtkLengthDistribution'
    
    m_SortSample: bpy.props.BoolProperty(name='SortSample', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_SampleSize: bpy.props.IntProperty(name='SampleSize', default=100000, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=3, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_SortSample','m_ObjectName','m_SampleSize',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKLengthDistribution )        
TYPENAMES.append('VTKLengthDistributionType' )

#--------------------------------------------------------------
class VTKLevelIdScalars(Node, BVTK_Node):

    bl_idname = 'VTKLevelIdScalarsType'
    bl_label  = 'vtkLevelIdScalars'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKLevelIdScalars )        
TYPENAMES.append('VTKLevelIdScalarsType' )

#--------------------------------------------------------------
class VTKLinearCellExtrusionFilter(Node, BVTK_Node):

    bl_idname = 'VTKLinearCellExtrusionFilterType'
    bl_label  = 'vtkLinearCellExtrusionFilter'
    
    m_MergeDuplicatePoints: bpy.props.BoolProperty(name='MergeDuplicatePoints', default=False, update=BVTK_Node.outdate_vtk_status)
    m_UseUserVector: bpy.props.BoolProperty(name='UseUserVector', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_ScaleFactor: bpy.props.FloatProperty(name='ScaleFactor', default=1.0, update=BVTK_Node.outdate_vtk_status)
    m_UserVector: bpy.props.FloatVectorProperty(name='UserVector', default=[0.0, 0.0, 1.0], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=5, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_MergeDuplicatePoints','m_UseUserVector','m_ObjectName','m_ScaleFactor','m_UserVector',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKLinearCellExtrusionFilter )        
TYPENAMES.append('VTKLinearCellExtrusionFilterType' )

#--------------------------------------------------------------
class VTKLinearExtrusionFilter(Node, BVTK_Node):

    bl_idname = 'VTKLinearExtrusionFilterType'
    bl_label  = 'vtkLinearExtrusionFilter'
    e_ExtrusionType_items=[ (x,x,x) for x in ['VectorExtrusion', 'NormalExtrusion', 'PointExtrusion']]
    
    m_Capping: bpy.props.BoolProperty(name='Capping', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_ScaleFactor: bpy.props.FloatProperty(name='ScaleFactor', default=1.0, update=BVTK_Node.outdate_vtk_status)
    e_ExtrusionType: bpy.props.EnumProperty(name='ExtrusionType', default="NormalExtrusion", items=e_ExtrusionType_items, update=BVTK_Node.outdate_vtk_status)
    m_ExtrusionPoint: bpy.props.FloatVectorProperty(name='ExtrusionPoint', default=[0.0, 0.0, 0.0], size=3, update=BVTK_Node.outdate_vtk_status)
    m_Vector: bpy.props.FloatVectorProperty(name='Vector', default=[0.0, 0.0, 1.0], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=6, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_Capping','m_ObjectName','m_ScaleFactor','e_ExtrusionType','m_ExtrusionPoint','m_Vector',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKLinearExtrusionFilter )        
TYPENAMES.append('VTKLinearExtrusionFilterType' )

#--------------------------------------------------------------
class VTKLinearSelector(Node, BVTK_Node):

    bl_idname = 'VTKLinearSelectorType'
    bl_label  = 'vtkLinearSelector'
    
    m_IncludeVertices: bpy.props.BoolProperty(name='IncludeVertices', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_Tolerance: bpy.props.FloatProperty(name='Tolerance', default=0.0, update=BVTK_Node.outdate_vtk_status)
    m_VertexEliminationTolerance: bpy.props.FloatProperty(name='VertexEliminationTolerance', default=1e-06, update=BVTK_Node.outdate_vtk_status)
    m_EndPoint: bpy.props.FloatVectorProperty(name='EndPoint', default=[1.0, 1.0, 1.0], size=3, update=BVTK_Node.outdate_vtk_status)
    m_StartPoint: bpy.props.FloatVectorProperty(name='StartPoint', default=[0.0, 0.0, 0.0], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=6, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_IncludeVertices','m_ObjectName','m_Tolerance','m_VertexEliminationTolerance','m_EndPoint','m_StartPoint',]
    def m_connections( self ):
        return (['input'], ['output'], ['Points'], []) 
    
add_class( VTKLinearSelector )        
TYPENAMES.append('VTKLinearSelectorType' )

#--------------------------------------------------------------
class VTKLinearSubdivisionFilter(Node, BVTK_Node):

    bl_idname = 'VTKLinearSubdivisionFilterType'
    bl_label  = 'vtkLinearSubdivisionFilter'
    
    m_CheckForTriangles: bpy.props.BoolProperty(name='CheckForTriangles', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_NumberOfSubdivisions: bpy.props.IntProperty(name='NumberOfSubdivisions', default=1, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=3, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_CheckForTriangles','m_ObjectName','m_NumberOfSubdivisions',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKLinearSubdivisionFilter )        
TYPENAMES.append('VTKLinearSubdivisionFilterType' )

#--------------------------------------------------------------
class VTKLinearToQuadraticCellsFilter(Node, BVTK_Node):

    bl_idname = 'VTKLinearToQuadraticCellsFilterType'
    bl_label  = 'vtkLinearToQuadraticCellsFilter'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKLinearToQuadraticCellsFilter )        
TYPENAMES.append('VTKLinearToQuadraticCellsFilterType' )

#--------------------------------------------------------------
class VTKLinkEdgels(Node, BVTK_Node):

    bl_idname = 'VTKLinkEdgelsType'
    bl_label  = 'vtkLinkEdgels'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_GradientThreshold: bpy.props.FloatProperty(name='GradientThreshold', default=0.1, update=BVTK_Node.outdate_vtk_status)
    m_LinkThreshold: bpy.props.FloatProperty(name='LinkThreshold', default=90.0, update=BVTK_Node.outdate_vtk_status)
    m_PhiThreshold: bpy.props.FloatProperty(name='PhiThreshold', default=90.0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=4, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_GradientThreshold','m_LinkThreshold','m_PhiThreshold',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKLinkEdgels )        
TYPENAMES.append('VTKLinkEdgelsType' )

#--------------------------------------------------------------
class VTKLoopSubdivisionFilter(Node, BVTK_Node):

    bl_idname = 'VTKLoopSubdivisionFilterType'
    bl_label  = 'vtkLoopSubdivisionFilter'
    
    m_CheckForTriangles: bpy.props.BoolProperty(name='CheckForTriangles', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_NumberOfSubdivisions: bpy.props.IntProperty(name='NumberOfSubdivisions', default=1, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=3, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_CheckForTriangles','m_ObjectName','m_NumberOfSubdivisions',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKLoopSubdivisionFilter )        
TYPENAMES.append('VTKLoopSubdivisionFilterType' )

#--------------------------------------------------------------
class VTKMapArrayValues(Node, BVTK_Node):

    bl_idname = 'VTKMapArrayValuesType'
    bl_label  = 'vtkMapArrayValues'
    
    m_PassArray: bpy.props.BoolProperty(name='PassArray', default=True, update=BVTK_Node.outdate_vtk_status)
    m_InputArrayName: bpy.props.StringProperty(name='InputArrayName', default="", update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_OutputArrayName: bpy.props.StringProperty(name='OutputArrayName', default="ArrayMap", update=BVTK_Node.outdate_vtk_status)
    m_FieldType: bpy.props.IntProperty(name='FieldType', default=0, update=BVTK_Node.outdate_vtk_status)
    m_OutputArrayType: bpy.props.IntProperty(name='OutputArrayType', default=6, update=BVTK_Node.outdate_vtk_status)
    m_FillValue: bpy.props.FloatProperty(name='FillValue', default=-1.0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=7, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_PassArray','m_InputArrayName','m_ObjectName','m_OutputArrayName','m_FieldType','m_OutputArrayType','m_FillValue',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKMapArrayValues )        
TYPENAMES.append('VTKMapArrayValuesType' )

#--------------------------------------------------------------
class VTKMarchingContourFilter(Node, BVTK_Node):

    bl_idname = 'VTKMarchingContourFilterType'
    bl_label  = 'vtkMarchingContourFilter'
    
    m_ComputeGradients: bpy.props.BoolProperty(name='ComputeGradients', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ComputeNormals: bpy.props.BoolProperty(name='ComputeNormals', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ComputeScalars: bpy.props.BoolProperty(name='ComputeScalars', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_NumberOfContours: bpy.props.IntProperty(name='NumberOfContours', default=1, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=5, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ComputeGradients','m_ComputeNormals','m_ComputeScalars','m_ObjectName','m_NumberOfContours',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKMarchingContourFilter )        
TYPENAMES.append('VTKMarchingContourFilterType' )

#--------------------------------------------------------------
class VTKMarchingCubes(Node, BVTK_Node):

    bl_idname = 'VTKMarchingCubesType'
    bl_label  = 'vtkMarchingCubes'
    
    m_ComputeGradients: bpy.props.BoolProperty(name='ComputeGradients', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ComputeNormals: bpy.props.BoolProperty(name='ComputeNormals', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ComputeScalars: bpy.props.BoolProperty(name='ComputeScalars', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_NumberOfContours: bpy.props.IntProperty(name='NumberOfContours', default=1, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=5, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ComputeGradients','m_ComputeNormals','m_ComputeScalars','m_ObjectName','m_NumberOfContours',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKMarchingCubes )        
TYPENAMES.append('VTKMarchingCubesType' )

#--------------------------------------------------------------
class VTKMarchingSquares(Node, BVTK_Node):

    bl_idname = 'VTKMarchingSquaresType'
    bl_label  = 'vtkMarchingSquares'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_NumberOfContours: bpy.props.IntProperty(name='NumberOfContours', default=1, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_NumberOfContours',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKMarchingSquares )        
TYPENAMES.append('VTKMarchingSquaresType' )

#--------------------------------------------------------------
class VTKMarkBoundaryFilter(Node, BVTK_Node):

    bl_idname = 'VTKMarkBoundaryFilterType'
    bl_label  = 'vtkMarkBoundaryFilter'
    
    m_GenerateBoundaryFaces: bpy.props.BoolProperty(name='GenerateBoundaryFaces', default=False, update=BVTK_Node.outdate_vtk_status)
    m_BoundaryCellsName: bpy.props.StringProperty(name='BoundaryCellsName', default="BoundaryCells", update=BVTK_Node.outdate_vtk_status)
    m_BoundaryFacesName: bpy.props.StringProperty(name='BoundaryFacesName', default="BoundaryFaces", update=BVTK_Node.outdate_vtk_status)
    m_BoundaryPointsName: bpy.props.StringProperty(name='BoundaryPointsName', default="BoundaryPoints", update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=5, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_GenerateBoundaryFaces','m_BoundaryCellsName','m_BoundaryFacesName','m_BoundaryPointsName','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKMarkBoundaryFilter )        
TYPENAMES.append('VTKMarkBoundaryFilterType' )

#--------------------------------------------------------------
class VTKMaskFields(Node, BVTK_Node):

    bl_idname = 'VTKMaskFieldsType'
    bl_label  = 'vtkMaskFields'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKMaskFields )        
TYPENAMES.append('VTKMaskFieldsType' )

#--------------------------------------------------------------
class VTKMaskPoints(Node, BVTK_Node):

    bl_idname = 'VTKMaskPointsType'
    bl_label  = 'vtkMaskPoints'
    
    m_GenerateVertices: bpy.props.BoolProperty(name='GenerateVertices', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ProportionalMaximumNumberOfPoints: bpy.props.BoolProperty(name='ProportionalMaximumNumberOfPoints', default=False, update=BVTK_Node.outdate_vtk_status)
    m_RandomMode: bpy.props.BoolProperty(name='RandomMode', default=False, update=BVTK_Node.outdate_vtk_status)
    m_SingleVertexPerCell: bpy.props.BoolProperty(name='SingleVertexPerCell', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_MaximumNumberOfPoints: bpy.props.IntProperty(name='MaximumNumberOfPoints', default=1000000000, update=BVTK_Node.outdate_vtk_status)
    m_Offset: bpy.props.IntProperty(name='Offset', default=0, update=BVTK_Node.outdate_vtk_status)
    m_OnRatio: bpy.props.IntProperty(name='OnRatio', default=2, update=BVTK_Node.outdate_vtk_status)
    m_RandomModeType: bpy.props.IntProperty(name='RandomModeType', default=0, update=BVTK_Node.outdate_vtk_status)
    m_RandomSeed: bpy.props.IntProperty(name='RandomSeed', default=1, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=10, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_GenerateVertices','m_ProportionalMaximumNumberOfPoints','m_RandomMode','m_SingleVertexPerCell','m_ObjectName','m_MaximumNumberOfPoints','m_Offset','m_OnRatio','m_RandomModeType','m_RandomSeed',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKMaskPoints )        
TYPENAMES.append('VTKMaskPointsType' )

#--------------------------------------------------------------
class VTKMaskPolyData(Node, BVTK_Node):

    bl_idname = 'VTKMaskPolyDataType'
    bl_label  = 'vtkMaskPolyData'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_Offset: bpy.props.IntProperty(name='Offset', default=0, update=BVTK_Node.outdate_vtk_status)
    m_OnRatio: bpy.props.IntProperty(name='OnRatio', default=11, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=3, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_Offset','m_OnRatio',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKMaskPolyData )        
TYPENAMES.append('VTKMaskPolyDataType' )

#--------------------------------------------------------------
class VTKMatricizeArray(Node, BVTK_Node):

    bl_idname = 'VTKMatricizeArrayType'
    bl_label  = 'vtkMatricizeArray'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_SliceDimension: bpy.props.IntProperty(name='SliceDimension', default=0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_SliceDimension',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKMatricizeArray )        
TYPENAMES.append('VTKMatricizeArrayType' )

#--------------------------------------------------------------
class VTKMatrixMathFilter(Node, BVTK_Node):

    bl_idname = 'VTKMatrixMathFilterType'
    bl_label  = 'vtkMatrixMathFilter'
    e_Operation_items=[ (x,x,x) for x in ['Determinant', 'Eigenvalue', 'Eigenvector', 'Inverse']]
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    e_Operation: bpy.props.EnumProperty(name='Operation', default="Determinant", items=e_Operation_items, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','e_Operation',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKMatrixMathFilter )        
TYPENAMES.append('VTKMatrixMathFilterType' )

#--------------------------------------------------------------
class VTKMemoryLimitImageDataStreamer(Node, BVTK_Node):

    bl_idname = 'VTKMemoryLimitImageDataStreamerType'
    bl_label  = 'vtkMemoryLimitImageDataStreamer'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_MemoryLimit: bpy.props.IntProperty(name='MemoryLimit', default=51200, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfStreamDivisions: bpy.props.IntProperty(name='NumberOfStreamDivisions', default=10, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=3, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_MemoryLimit','m_NumberOfStreamDivisions',]
    def m_connections( self ):
        return (['input'], ['output'], ['ExtentTranslator'], []) 
    
add_class( VTKMemoryLimitImageDataStreamer )        
TYPENAMES.append('VTKMemoryLimitImageDataStreamerType' )

#--------------------------------------------------------------
class VTKMergeArrays(Node, BVTK_Node):

    bl_idname = 'VTKMergeArraysType'
    bl_label  = 'vtkMergeArrays'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKMergeArrays )        
TYPENAMES.append('VTKMergeArraysType' )

#--------------------------------------------------------------
class VTKMergeFields(Node, BVTK_Node):

    bl_idname = 'VTKMergeFieldsType'
    bl_label  = 'vtkMergeFields'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_NumberOfComponents: bpy.props.IntProperty(name='NumberOfComponents', default=0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_NumberOfComponents',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKMergeFields )        
TYPENAMES.append('VTKMergeFieldsType' )

#--------------------------------------------------------------
class VTKMergeTimeFilter(Node, BVTK_Node):

    bl_idname = 'VTKMergeTimeFilterType'
    bl_label  = 'vtkMergeTimeFilter'
    
    m_UseIntersection: bpy.props.BoolProperty(name='UseIntersection', default=False, update=BVTK_Node.outdate_vtk_status)
    m_UseRelativeTolerance: bpy.props.BoolProperty(name='UseRelativeTolerance', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_Tolerance: bpy.props.FloatProperty(name='Tolerance', default=1e-05, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=4, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_UseIntersection','m_UseRelativeTolerance','m_ObjectName','m_Tolerance',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKMergeTimeFilter )        
TYPENAMES.append('VTKMergeTimeFilterType' )

#--------------------------------------------------------------
class VTKMergeVectorComponents(Node, BVTK_Node):

    bl_idname = 'VTKMergeVectorComponentsType'
    bl_label  = 'vtkMergeVectorComponents'
    e_AttributeType_items=[ (x,x,x) for x in ['PointData', 'CellData']]
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_OutputVectorName: bpy.props.StringProperty(name='OutputVectorName', default="", update=BVTK_Node.outdate_vtk_status)
    m_XArrayName: bpy.props.StringProperty(name='XArrayName', default="", update=BVTK_Node.outdate_vtk_status)
    m_YArrayName: bpy.props.StringProperty(name='YArrayName', default="", update=BVTK_Node.outdate_vtk_status)
    m_ZArrayName: bpy.props.StringProperty(name='ZArrayName', default="", update=BVTK_Node.outdate_vtk_status)
    e_AttributeType: bpy.props.EnumProperty(name='AttributeType', default="PointData", items=e_AttributeType_items, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=6, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_OutputVectorName','m_XArrayName','m_YArrayName','m_ZArrayName','e_AttributeType',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKMergeVectorComponents )        
TYPENAMES.append('VTKMergeVectorComponentsType' )

#--------------------------------------------------------------
class VTKMeshQuality(Node, BVTK_Node):

    bl_idname = 'VTKMeshQualityType'
    bl_label  = 'vtkMeshQuality'
    
    m_CompatibilityMode: bpy.props.BoolProperty(name='CompatibilityMode', default=True, update=BVTK_Node.outdate_vtk_status)
    m_LinearApproximation: bpy.props.BoolProperty(name='LinearApproximation', default=False, update=BVTK_Node.outdate_vtk_status)
    m_Ratio: bpy.props.BoolProperty(name='Ratio', default=True, update=BVTK_Node.outdate_vtk_status)
    m_SaveCellQuality: bpy.props.BoolProperty(name='SaveCellQuality', default=True, update=BVTK_Node.outdate_vtk_status)
    m_Volume: bpy.props.BoolProperty(name='Volume', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=6, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_CompatibilityMode','m_LinearApproximation','m_Ratio','m_SaveCellQuality','m_Volume','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], ['HexQualityMeasure', 'PyramidQualityMeasure', 'QuadQualityMeasure', 'TetQualityMeasure', 'TriangleQualityMeasure', 'WedgeQualityMeasure'], []) 
    
add_class( VTKMeshQuality )        
TYPENAMES.append('VTKMeshQualityType' )

#--------------------------------------------------------------
class VTKMoleculeAlgorithm(Node, BVTK_Node):

    bl_idname = 'VTKMoleculeAlgorithmType'
    bl_label  = 'vtkMoleculeAlgorithm'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKMoleculeAlgorithm )        
TYPENAMES.append('VTKMoleculeAlgorithmType' )

#--------------------------------------------------------------
class VTKMoleculeAppend(Node, BVTK_Node):

    bl_idname = 'VTKMoleculeAppendType'
    bl_label  = 'vtkMoleculeAppend'
    
    m_MergeCoincidentAtoms: bpy.props.BoolProperty(name='MergeCoincidentAtoms', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_MergeCoincidentAtoms','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKMoleculeAppend )        
TYPENAMES.append('VTKMoleculeAppendType' )

#--------------------------------------------------------------
class VTKMoleculeToAtomBallFilter(Node, BVTK_Node):

    bl_idname = 'VTKMoleculeToAtomBallFilterType'
    bl_label  = 'vtkMoleculeToAtomBallFilter'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_RadiusSource: bpy.props.IntProperty(name='RadiusSource', default=0, update=BVTK_Node.outdate_vtk_status)
    m_Resolution: bpy.props.IntProperty(name='Resolution', default=50, update=BVTK_Node.outdate_vtk_status)
    m_RadiusScale: bpy.props.FloatProperty(name='RadiusScale', default=0.8, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=4, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_RadiusSource','m_Resolution','m_RadiusScale',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKMoleculeToAtomBallFilter )        
TYPENAMES.append('VTKMoleculeToAtomBallFilterType' )

#--------------------------------------------------------------
class VTKMoleculeToBondStickFilter(Node, BVTK_Node):

    bl_idname = 'VTKMoleculeToBondStickFilterType'
    bl_label  = 'vtkMoleculeToBondStickFilter'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKMoleculeToBondStickFilter )        
TYPENAMES.append('VTKMoleculeToBondStickFilterType' )

#--------------------------------------------------------------
class VTKMoleculeToLinesFilter(Node, BVTK_Node):

    bl_idname = 'VTKMoleculeToLinesFilterType'
    bl_label  = 'vtkMoleculeToLinesFilter'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKMoleculeToLinesFilter )        
TYPENAMES.append('VTKMoleculeToLinesFilterType' )

#--------------------------------------------------------------
class VTKMultiBlockDataGroupFilter(Node, BVTK_Node):

    bl_idname = 'VTKMultiBlockDataGroupFilterType'
    bl_label  = 'vtkMultiBlockDataGroupFilter'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKMultiBlockDataGroupFilter )        
TYPENAMES.append('VTKMultiBlockDataGroupFilterType' )

#--------------------------------------------------------------
class VTKMultiBlockDataSetAlgorithm(Node, BVTK_Node):

    bl_idname = 'VTKMultiBlockDataSetAlgorithmType'
    bl_label  = 'vtkMultiBlockDataSetAlgorithm'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKMultiBlockDataSetAlgorithm )        
TYPENAMES.append('VTKMultiBlockDataSetAlgorithmType' )

#--------------------------------------------------------------
class VTKMultiBlockFromTimeSeriesFilter(Node, BVTK_Node):

    bl_idname = 'VTKMultiBlockFromTimeSeriesFilterType'
    bl_label  = 'vtkMultiBlockFromTimeSeriesFilter'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKMultiBlockFromTimeSeriesFilter )        
TYPENAMES.append('VTKMultiBlockFromTimeSeriesFilterType' )

#--------------------------------------------------------------
class VTKMultiBlockMergeFilter(Node, BVTK_Node):

    bl_idname = 'VTKMultiBlockMergeFilterType'
    bl_label  = 'vtkMultiBlockMergeFilter'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKMultiBlockMergeFilter )        
TYPENAMES.append('VTKMultiBlockMergeFilterType' )

#--------------------------------------------------------------
class VTKMultiObjectMassProperties(Node, BVTK_Node):

    bl_idname = 'VTKMultiObjectMassPropertiesType'
    bl_label  = 'vtkMultiObjectMassProperties'
    
    m_SkipValidityCheck: bpy.props.BoolProperty(name='SkipValidityCheck', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectIdsArrayName: bpy.props.StringProperty(name='ObjectIdsArrayName', default="ObjectIds", update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=3, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_SkipValidityCheck','m_ObjectIdsArrayName','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKMultiObjectMassProperties )        
TYPENAMES.append('VTKMultiObjectMassPropertiesType' )

#--------------------------------------------------------------
class VTKMultiThreshold(Node, BVTK_Node):

    bl_idname = 'VTKMultiThresholdType'
    bl_label  = 'vtkMultiThreshold'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKMultiThreshold )        
TYPENAMES.append('VTKMultiThresholdType' )

#--------------------------------------------------------------
class VTKNonOverlappingAMRAlgorithm(Node, BVTK_Node):

    bl_idname = 'VTKNonOverlappingAMRAlgorithmType'
    bl_label  = 'vtkNonOverlappingAMRAlgorithm'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKNonOverlappingAMRAlgorithm )        
TYPENAMES.append('VTKNonOverlappingAMRAlgorithmType' )

#--------------------------------------------------------------
class VTKNormalizeMatrixVectors(Node, BVTK_Node):

    bl_idname = 'VTKNormalizeMatrixVectorsType'
    bl_label  = 'vtkNormalizeMatrixVectors'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_VectorDimension: bpy.props.IntProperty(name='VectorDimension', default=1, update=BVTK_Node.outdate_vtk_status)
    m_PValue: bpy.props.FloatProperty(name='PValue', default=2.0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=3, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_VectorDimension','m_PValue',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKNormalizeMatrixVectors )        
TYPENAMES.append('VTKNormalizeMatrixVectorsType' )

#--------------------------------------------------------------
class VTKOBBDicer(Node, BVTK_Node):

    bl_idname = 'VTKOBBDicerType'
    bl_label  = 'vtkOBBDicer'
    e_DiceMode_items=[ (x,x,x) for x in ['NumberOfPointsPerPiece', 'SpecifiedNumberOfPieces', 'MemoryLimitPerPiece']]
    
    m_FieldData: bpy.props.BoolProperty(name='FieldData', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_MemoryLimit: bpy.props.IntProperty(name='MemoryLimit', default=51200, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfPieces: bpy.props.IntProperty(name='NumberOfPieces', default=10, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfPointsPerPiece: bpy.props.IntProperty(name='NumberOfPointsPerPiece', default=5000, update=BVTK_Node.outdate_vtk_status)
    e_DiceMode: bpy.props.EnumProperty(name='DiceMode', default="NumberOfPointsPerPiece", items=e_DiceMode_items, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=6, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_FieldData','m_ObjectName','m_MemoryLimit','m_NumberOfPieces','m_NumberOfPointsPerPiece','e_DiceMode',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKOBBDicer )        
TYPENAMES.append('VTKOBBDicerType' )

#--------------------------------------------------------------
class VTKOpenGLImageGradient(Node, BVTK_Node):

    bl_idname = 'VTKOpenGLImageGradientType'
    bl_label  = 'vtkOpenGLImageGradient'
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_HandleBoundaries: bpy.props.BoolProperty(name='HandleBoundaries', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_Dimensionality: bpy.props.IntProperty(name='Dimensionality', default=2, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=1, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=9, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_EnableSMP','m_GlobalDefaultEnableSMP','m_HandleBoundaries','m_ObjectName','m_DesiredBytesPerPiece','m_Dimensionality','m_NumberOfThreads','e_SplitMode','m_MinimumPieceSize',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKOpenGLImageGradient )        
TYPENAMES.append('VTKOpenGLImageGradientType' )

#--------------------------------------------------------------
class VTKOutlineCornerFilter(Node, BVTK_Node):

    bl_idname = 'VTKOutlineCornerFilterType'
    bl_label  = 'vtkOutlineCornerFilter'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_CornerFactor: bpy.props.FloatProperty(name='CornerFactor', default=0.2, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_CornerFactor',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKOutlineCornerFilter )        
TYPENAMES.append('VTKOutlineCornerFilterType' )

#--------------------------------------------------------------
class VTKOutlineFilter(Node, BVTK_Node):

    bl_idname = 'VTKOutlineFilterType'
    bl_label  = 'vtkOutlineFilter'
    e_CompositeStyle_items=[ (x,x,x) for x in ['Root', 'Leafs', 'RootAndLeafs', 'SpecifiedIndex']]
    
    m_GenerateFaces: bpy.props.BoolProperty(name='GenerateFaces', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    e_CompositeStyle: bpy.props.EnumProperty(name='CompositeStyle', default="RootAndLeafs", items=e_CompositeStyle_items, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=3, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_GenerateFaces','m_ObjectName','e_CompositeStyle',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKOutlineFilter )        
TYPENAMES.append('VTKOutlineFilterType' )

#--------------------------------------------------------------
class VTKOverlappingAMRAlgorithm(Node, BVTK_Node):

    bl_idname = 'VTKOverlappingAMRAlgorithmType'
    bl_label  = 'vtkOverlappingAMRAlgorithm'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKOverlappingAMRAlgorithm )        
TYPENAMES.append('VTKOverlappingAMRAlgorithmType' )

#--------------------------------------------------------------
class VTKOverlappingAMRLevelIdScalars(Node, BVTK_Node):

    bl_idname = 'VTKOverlappingAMRLevelIdScalarsType'
    bl_label  = 'vtkOverlappingAMRLevelIdScalars'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKOverlappingAMRLevelIdScalars )        
TYPENAMES.append('VTKOverlappingAMRLevelIdScalarsType' )

#--------------------------------------------------------------
class VTKOverlappingCellsDetector(Node, BVTK_Node):

    bl_idname = 'VTKOverlappingCellsDetectorType'
    bl_label  = 'vtkOverlappingCellsDetector'
    
    m_NumberOfOverlapsPerCellArrayName: bpy.props.StringProperty(name='NumberOfOverlapsPerCellArrayName', default="NumberOfOverlapsPerCell", update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_Tolerance: bpy.props.FloatProperty(name='Tolerance', default=0.0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=3, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_NumberOfOverlapsPerCellArrayName','m_ObjectName','m_Tolerance',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKOverlappingCellsDetector )        
TYPENAMES.append('VTKOverlappingCellsDetectorType' )

#--------------------------------------------------------------
class VTKPCAAnalysisFilter(Node, BVTK_Node):

    bl_idname = 'VTKPCAAnalysisFilterType'
    bl_label  = 'vtkPCAAnalysisFilter'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKPCAAnalysisFilter )        
TYPENAMES.append('VTKPCAAnalysisFilterType' )

#--------------------------------------------------------------
class VTKPCACurvatureEstimation(Node, BVTK_Node):

    bl_idname = 'VTKPCACurvatureEstimationType'
    bl_label  = 'vtkPCACurvatureEstimation'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_SampleSize: bpy.props.IntProperty(name='SampleSize', default=25, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_SampleSize',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKPCACurvatureEstimation )        
TYPENAMES.append('VTKPCACurvatureEstimationType' )

#--------------------------------------------------------------
class VTKPCANormalEstimation(Node, BVTK_Node):

    bl_idname = 'VTKPCANormalEstimationType'
    bl_label  = 'vtkPCANormalEstimation'
    e_NormalOrientation_items=[ (x,x,x) for x in ['AsComputed', 'Point', 'GraphTraversal']]
    
    m_FlipNormals: bpy.props.BoolProperty(name='FlipNormals', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_SampleSize: bpy.props.IntProperty(name='SampleSize', default=25, update=BVTK_Node.outdate_vtk_status)
    e_NormalOrientation: bpy.props.EnumProperty(name='NormalOrientation', default="Point", items=e_NormalOrientation_items, update=BVTK_Node.outdate_vtk_status)
    m_OrientationPoint: bpy.props.FloatVectorProperty(name='OrientationPoint', default=[0.0, 0.0, 0.0], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=5, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_FlipNormals','m_ObjectName','m_SampleSize','e_NormalOrientation','m_OrientationPoint',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKPCANormalEstimation )        
TYPENAMES.append('VTKPCANormalEstimationType' )

#--------------------------------------------------------------
class VTKPCellDataToPointData(Node, BVTK_Node):

    bl_idname = 'VTKPCellDataToPointDataType'
    bl_label  = 'vtkPCellDataToPointData'
    
    m_PassCellData: bpy.props.BoolProperty(name='PassCellData', default=False, update=BVTK_Node.outdate_vtk_status)
    m_PieceInvariant: bpy.props.BoolProperty(name='PieceInvariant', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ProcessAllArrays: bpy.props.BoolProperty(name='ProcessAllArrays', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_ContributingCellOption: bpy.props.IntProperty(name='ContributingCellOption', default=0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=5, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_PassCellData','m_PieceInvariant','m_ProcessAllArrays','m_ObjectName','m_ContributingCellOption',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKPCellDataToPointData )        
TYPENAMES.append('VTKPCellDataToPointDataType' )

#--------------------------------------------------------------
class VTKPComputeQuantiles(Node, BVTK_Node):

    bl_idname = 'VTKPComputeQuantilesType'
    bl_label  = 'vtkPComputeQuantiles'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_NumberOfIntervals: bpy.props.IntProperty(name='NumberOfIntervals', default=4, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_NumberOfIntervals',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKPComputeQuantiles )        
TYPENAMES.append('VTKPComputeQuantilesType' )

#--------------------------------------------------------------
class VTKPComputeQuartiles(Node, BVTK_Node):

    bl_idname = 'VTKPComputeQuartilesType'
    bl_label  = 'vtkPComputeQuartiles'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_NumberOfIntervals: bpy.props.IntProperty(name='NumberOfIntervals', default=4, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_NumberOfIntervals',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKPComputeQuartiles )        
TYPENAMES.append('VTKPComputeQuartilesType' )

#--------------------------------------------------------------
class VTKPConvertToMultiBlockDataSet(Node, BVTK_Node):

    bl_idname = 'VTKPConvertToMultiBlockDataSetType'
    bl_label  = 'vtkPConvertToMultiBlockDataSet'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKPConvertToMultiBlockDataSet )        
TYPENAMES.append('VTKPConvertToMultiBlockDataSetType' )

#--------------------------------------------------------------
class VTKPExtractDataArraysOverTime(Node, BVTK_Node):

    bl_idname = 'VTKPExtractDataArraysOverTimeType'
    bl_label  = 'vtkPExtractDataArraysOverTime'
    
    m_ReportStatisticsOnly: bpy.props.BoolProperty(name='ReportStatisticsOnly', default=False, update=BVTK_Node.outdate_vtk_status)
    m_UseGlobalIDs: bpy.props.BoolProperty(name='UseGlobalIDs', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_FieldAssociation: bpy.props.IntProperty(name='FieldAssociation', default=0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=4, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ReportStatisticsOnly','m_UseGlobalIDs','m_ObjectName','m_FieldAssociation',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKPExtractDataArraysOverTime )        
TYPENAMES.append('VTKPExtractDataArraysOverTimeType' )

#--------------------------------------------------------------
class VTKPExtractExodusGlobalTemporalVariables(Node, BVTK_Node):

    bl_idname = 'VTKPExtractExodusGlobalTemporalVariablesType'
    bl_label  = 'vtkPExtractExodusGlobalTemporalVariables'
    
    m_AutoDetectGlobalTemporalDataArrays: bpy.props.BoolProperty(name='AutoDetectGlobalTemporalDataArrays', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_AutoDetectGlobalTemporalDataArrays','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKPExtractExodusGlobalTemporalVariables )        
TYPENAMES.append('VTKPExtractExodusGlobalTemporalVariablesType' )

#--------------------------------------------------------------
class VTKPLinearExtrusionFilter(Node, BVTK_Node):

    bl_idname = 'VTKPLinearExtrusionFilterType'
    bl_label  = 'vtkPLinearExtrusionFilter'
    e_ExtrusionType_items=[ (x,x,x) for x in ['VectorExtrusion', 'NormalExtrusion', 'PointExtrusion']]
    
    m_Capping: bpy.props.BoolProperty(name='Capping', default=True, update=BVTK_Node.outdate_vtk_status)
    m_PieceInvariant: bpy.props.BoolProperty(name='PieceInvariant', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_ScaleFactor: bpy.props.FloatProperty(name='ScaleFactor', default=1.0, update=BVTK_Node.outdate_vtk_status)
    e_ExtrusionType: bpy.props.EnumProperty(name='ExtrusionType', default="NormalExtrusion", items=e_ExtrusionType_items, update=BVTK_Node.outdate_vtk_status)
    m_ExtrusionPoint: bpy.props.FloatVectorProperty(name='ExtrusionPoint', default=[0.0, 0.0, 0.0], size=3, update=BVTK_Node.outdate_vtk_status)
    m_Vector: bpy.props.FloatVectorProperty(name='Vector', default=[0.0, 0.0, 1.0], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=7, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_Capping','m_PieceInvariant','m_ObjectName','m_ScaleFactor','e_ExtrusionType','m_ExtrusionPoint','m_Vector',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKPLinearExtrusionFilter )        
TYPENAMES.append('VTKPLinearExtrusionFilterType' )

#--------------------------------------------------------------
class VTKPMaskPoints(Node, BVTK_Node):

    bl_idname = 'VTKPMaskPointsType'
    bl_label  = 'vtkPMaskPoints'
    
    m_GenerateVertices: bpy.props.BoolProperty(name='GenerateVertices', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ProportionalMaximumNumberOfPoints: bpy.props.BoolProperty(name='ProportionalMaximumNumberOfPoints', default=False, update=BVTK_Node.outdate_vtk_status)
    m_RandomMode: bpy.props.BoolProperty(name='RandomMode', default=False, update=BVTK_Node.outdate_vtk_status)
    m_SingleVertexPerCell: bpy.props.BoolProperty(name='SingleVertexPerCell', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_MaximumNumberOfPoints: bpy.props.IntProperty(name='MaximumNumberOfPoints', default=1000000000, update=BVTK_Node.outdate_vtk_status)
    m_Offset: bpy.props.IntProperty(name='Offset', default=0, update=BVTK_Node.outdate_vtk_status)
    m_OnRatio: bpy.props.IntProperty(name='OnRatio', default=2, update=BVTK_Node.outdate_vtk_status)
    m_RandomModeType: bpy.props.IntProperty(name='RandomModeType', default=0, update=BVTK_Node.outdate_vtk_status)
    m_RandomSeed: bpy.props.IntProperty(name='RandomSeed', default=1, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=10, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_GenerateVertices','m_ProportionalMaximumNumberOfPoints','m_RandomMode','m_SingleVertexPerCell','m_ObjectName','m_MaximumNumberOfPoints','m_Offset','m_OnRatio','m_RandomModeType','m_RandomSeed',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKPMaskPoints )        
TYPENAMES.append('VTKPMaskPointsType' )

#--------------------------------------------------------------
class VTKPMergeArrays(Node, BVTK_Node):

    bl_idname = 'VTKPMergeArraysType'
    bl_label  = 'vtkPMergeArrays'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKPMergeArrays )        
TYPENAMES.append('VTKPMergeArraysType' )

#--------------------------------------------------------------
class VTKPOutlineCornerFilter(Node, BVTK_Node):

    bl_idname = 'VTKPOutlineCornerFilterType'
    bl_label  = 'vtkPOutlineCornerFilter'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_CornerFactor: bpy.props.FloatProperty(name='CornerFactor', default=0.2, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_CornerFactor',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKPOutlineCornerFilter )        
TYPENAMES.append('VTKPOutlineCornerFilterType' )

#--------------------------------------------------------------
class VTKPOutlineFilter(Node, BVTK_Node):

    bl_idname = 'VTKPOutlineFilterType'
    bl_label  = 'vtkPOutlineFilter'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKPOutlineFilter )        
TYPENAMES.append('VTKPOutlineFilterType' )

#--------------------------------------------------------------
class VTKPPolyDataNormals(Node, BVTK_Node):

    bl_idname = 'VTKPPolyDataNormalsType'
    bl_label  = 'vtkPPolyDataNormals'
    
    m_AutoOrientNormals: bpy.props.BoolProperty(name='AutoOrientNormals', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ComputeCellNormals: bpy.props.BoolProperty(name='ComputeCellNormals', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ComputePointNormals: bpy.props.BoolProperty(name='ComputePointNormals', default=True, update=BVTK_Node.outdate_vtk_status)
    m_Consistency: bpy.props.BoolProperty(name='Consistency', default=True, update=BVTK_Node.outdate_vtk_status)
    m_FlipNormals: bpy.props.BoolProperty(name='FlipNormals', default=True, update=BVTK_Node.outdate_vtk_status)
    m_NonManifoldTraversal: bpy.props.BoolProperty(name='NonManifoldTraversal', default=True, update=BVTK_Node.outdate_vtk_status)
    m_PieceInvariant: bpy.props.BoolProperty(name='PieceInvariant', default=True, update=BVTK_Node.outdate_vtk_status)
    m_Splitting: bpy.props.BoolProperty(name='Splitting', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_FeatureAngle: bpy.props.FloatProperty(name='FeatureAngle', default=30.0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=10, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_AutoOrientNormals','m_ComputeCellNormals','m_ComputePointNormals','m_Consistency','m_FlipNormals','m_NonManifoldTraversal','m_PieceInvariant','m_Splitting','m_ObjectName','m_FeatureAngle',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKPPolyDataNormals )        
TYPENAMES.append('VTKPPolyDataNormalsType' )

#--------------------------------------------------------------
class VTKPProjectSphereFilter(Node, BVTK_Node):

    bl_idname = 'VTKPProjectSphereFilterType'
    bl_label  = 'vtkPProjectSphereFilter'
    
    m_KeepPolePoints: bpy.props.BoolProperty(name='KeepPolePoints', default=False, update=BVTK_Node.outdate_vtk_status)
    m_TranslateZ: bpy.props.BoolProperty(name='TranslateZ', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_Center: bpy.props.FloatVectorProperty(name='Center', default=[0.0, 0.0, 0.0], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=4, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_KeepPolePoints','m_TranslateZ','m_ObjectName','m_Center',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKPProjectSphereFilter )        
TYPENAMES.append('VTKPProjectSphereFilterType' )

#--------------------------------------------------------------
class VTKPReflectionFilter(Node, BVTK_Node):

    bl_idname = 'VTKPReflectionFilterType'
    bl_label  = 'vtkPReflectionFilter'
    e_Plane_items=[ (x,x,x) for x in ['XMin', 'YMin', 'ZMin', 'XMax', 'YMax', 'ZMax', 'X', 'Y', 'Z']]
    
    m_CopyInput: bpy.props.BoolProperty(name='CopyInput', default=True, update=BVTK_Node.outdate_vtk_status)
    m_FlipAllInputArrays: bpy.props.BoolProperty(name='FlipAllInputArrays', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_Center: bpy.props.FloatProperty(name='Center', default=0.0, update=BVTK_Node.outdate_vtk_status)
    e_Plane: bpy.props.EnumProperty(name='Plane', default="XMin", items=e_Plane_items, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=5, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_CopyInput','m_FlipAllInputArrays','m_ObjectName','m_Center','e_Plane',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKPReflectionFilter )        
TYPENAMES.append('VTKPReflectionFilterType' )

#--------------------------------------------------------------
class VTKPResampleFilter(Node, BVTK_Node):

    bl_idname = 'VTKPResampleFilterType'
    bl_label  = 'vtkPResampleFilter'
    
    m_UseInputBounds: bpy.props.BoolProperty(name='UseInputBounds', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_SamplingDimension: bpy.props.IntVectorProperty(name='SamplingDimension', default=[10, 10, 10], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=3, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_UseInputBounds','m_ObjectName','m_SamplingDimension',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKPResampleFilter )        
TYPENAMES.append('VTKPResampleFilterType' )

#--------------------------------------------------------------
class VTKPResampleToImage(Node, BVTK_Node):

    bl_idname = 'VTKPResampleToImageType'
    bl_label  = 'vtkPResampleToImage'
    
    m_UseInputBounds: bpy.props.BoolProperty(name='UseInputBounds', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_SamplingDimensions: bpy.props.IntVectorProperty(name='SamplingDimensions', default=[10, 10, 10], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=3, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_UseInputBounds','m_ObjectName','m_SamplingDimensions',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKPResampleToImage )        
TYPENAMES.append('VTKPResampleToImageType' )

#--------------------------------------------------------------
class VTKPTextureMapToSphere(Node, BVTK_Node):

    bl_idname = 'VTKPTextureMapToSphereType'
    bl_label  = 'vtkPTextureMapToSphere'
    
    m_AutomaticSphereGeneration: bpy.props.BoolProperty(name='AutomaticSphereGeneration', default=True, update=BVTK_Node.outdate_vtk_status)
    m_PreventSeam: bpy.props.BoolProperty(name='PreventSeam', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_Center: bpy.props.FloatVectorProperty(name='Center', default=[0.0, 0.0, 0.0], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=4, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_AutomaticSphereGeneration','m_PreventSeam','m_ObjectName','m_Center',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKPTextureMapToSphere )        
TYPENAMES.append('VTKPTextureMapToSphereType' )

#--------------------------------------------------------------
class VTKPYoungsMaterialInterface(Node, BVTK_Node):

    bl_idname = 'VTKPYoungsMaterialInterfaceType'
    bl_label  = 'vtkPYoungsMaterialInterface'
    
    m_AxisSymetric: bpy.props.BoolProperty(name='AxisSymetric', default=True, update=BVTK_Node.outdate_vtk_status)
    m_FillMaterial: bpy.props.BoolProperty(name='FillMaterial', default=True, update=BVTK_Node.outdate_vtk_status)
    m_InverseNormal: bpy.props.BoolProperty(name='InverseNormal', default=True, update=BVTK_Node.outdate_vtk_status)
    m_OnionPeel: bpy.props.BoolProperty(name='OnionPeel', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ReverseMaterialOrder: bpy.props.BoolProperty(name='ReverseMaterialOrder', default=True, update=BVTK_Node.outdate_vtk_status)
    m_UseAllBlocks: bpy.props.BoolProperty(name='UseAllBlocks', default=True, update=BVTK_Node.outdate_vtk_status)
    m_UseFractionAsDistance: bpy.props.BoolProperty(name='UseFractionAsDistance', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_NumberOfMaterials: bpy.props.IntProperty(name='NumberOfMaterials', default=0, update=BVTK_Node.outdate_vtk_status)
    m_VolumeFractionRange: bpy.props.FloatVectorProperty(name='VolumeFractionRange', default=[0.01, 0.99], size=2, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=10, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_AxisSymetric','m_FillMaterial','m_InverseNormal','m_OnionPeel','m_ReverseMaterialOrder','m_UseAllBlocks','m_UseFractionAsDistance','m_ObjectName','m_NumberOfMaterials','m_VolumeFractionRange',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKPYoungsMaterialInterface )        
TYPENAMES.append('VTKPYoungsMaterialInterfaceType' )

#--------------------------------------------------------------
class VTKParallelVectors(Node, BVTK_Node):

    bl_idname = 'VTKParallelVectorsType'
    bl_label  = 'vtkParallelVectors'
    
    m_FirstVectorFieldName: bpy.props.StringProperty(name='FirstVectorFieldName', default="", update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_SecondVectorFieldName: bpy.props.StringProperty(name='SecondVectorFieldName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=3, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_FirstVectorFieldName','m_ObjectName','m_SecondVectorFieldName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKParallelVectors )        
TYPENAMES.append('VTKParallelVectorsType' )

#--------------------------------------------------------------
class VTKPartitionBalancer(Node, BVTK_Node):

    bl_idname = 'VTKPartitionBalancerType'
    bl_label  = 'vtkPartitionBalancer'
    e_Mode_items=[ (x,x,x) for x in ['Expand', 'Squash']]
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    e_Mode: bpy.props.EnumProperty(name='Mode', default="Squash", items=e_Mode_items, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','e_Mode',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKPartitionBalancer )        
TYPENAMES.append('VTKPartitionBalancerType' )

#--------------------------------------------------------------
class VTKPassArrays(Node, BVTK_Node):

    bl_idname = 'VTKPassArraysType'
    bl_label  = 'vtkPassArrays'
    
    m_RemoveArrays: bpy.props.BoolProperty(name='RemoveArrays', default=False, update=BVTK_Node.outdate_vtk_status)
    m_UseFieldTypes: bpy.props.BoolProperty(name='UseFieldTypes', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=3, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_RemoveArrays','m_UseFieldTypes','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKPassArrays )        
TYPENAMES.append('VTKPassArraysType' )

#--------------------------------------------------------------
class VTKPassInputTypeAlgorithm(Node, BVTK_Node):

    bl_idname = 'VTKPassInputTypeAlgorithmType'
    bl_label  = 'vtkPassInputTypeAlgorithm'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKPassInputTypeAlgorithm )        
TYPENAMES.append('VTKPassInputTypeAlgorithmType' )

#--------------------------------------------------------------
class VTKPassSelectedArrays(Node, BVTK_Node):

    bl_idname = 'VTKPassSelectedArraysType'
    bl_label  = 'vtkPassSelectedArrays'
    
    m_Enabled: bpy.props.BoolProperty(name='Enabled', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_Enabled','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKPassSelectedArrays )        
TYPENAMES.append('VTKPassSelectedArraysType' )

#--------------------------------------------------------------
class VTKPassThrough(Node, BVTK_Node):

    bl_idname = 'VTKPassThroughType'
    bl_label  = 'vtkPassThrough'
    
    m_AllowNullInput: bpy.props.BoolProperty(name='AllowNullInput', default=False, update=BVTK_Node.outdate_vtk_status)
    m_DeepCopyInput: bpy.props.BoolProperty(name='DeepCopyInput', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=3, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_AllowNullInput','m_DeepCopyInput','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKPassThrough )        
TYPENAMES.append('VTKPassThroughType' )

#--------------------------------------------------------------
class VTKPassThroughFilter(Node, BVTK_Node):

    bl_idname = 'VTKPassThroughFilterType'
    bl_label  = 'vtkPassThroughFilter'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKPassThroughFilter )        
TYPENAMES.append('VTKPassThroughFilterType' )

#--------------------------------------------------------------
class VTKPieceRequestFilter(Node, BVTK_Node):

    bl_idname = 'VTKPieceRequestFilterType'
    bl_label  = 'vtkPieceRequestFilter'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_NumberOfPieces: bpy.props.IntProperty(name='NumberOfPieces', default=1, update=BVTK_Node.outdate_vtk_status)
    m_Piece: bpy.props.IntProperty(name='Piece', default=0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=3, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_NumberOfPieces','m_Piece',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKPieceRequestFilter )        
TYPENAMES.append('VTKPieceRequestFilterType' )

#--------------------------------------------------------------
class VTKPieceScalars(Node, BVTK_Node):

    bl_idname = 'VTKPieceScalarsType'
    bl_label  = 'vtkPieceScalars'
    
    m_RandomMode: bpy.props.BoolProperty(name='RandomMode', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_RandomMode','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKPieceScalars )        
TYPENAMES.append('VTKPieceScalarsType' )

#--------------------------------------------------------------
class VTKPiecewiseFunctionAlgorithm(Node, BVTK_Node):

    bl_idname = 'VTKPiecewiseFunctionAlgorithmType'
    bl_label  = 'vtkPiecewiseFunctionAlgorithm'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKPiecewiseFunctionAlgorithm )        
TYPENAMES.append('VTKPiecewiseFunctionAlgorithmType' )

#--------------------------------------------------------------
class VTKPiecewiseFunctionShiftScale(Node, BVTK_Node):

    bl_idname = 'VTKPiecewiseFunctionShiftScaleType'
    bl_label  = 'vtkPiecewiseFunctionShiftScale'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_PositionScale: bpy.props.FloatProperty(name='PositionScale', default=1.0, update=BVTK_Node.outdate_vtk_status)
    m_PositionShift: bpy.props.FloatProperty(name='PositionShift', default=0.0, update=BVTK_Node.outdate_vtk_status)
    m_ValueScale: bpy.props.FloatProperty(name='ValueScale', default=1.0, update=BVTK_Node.outdate_vtk_status)
    m_ValueShift: bpy.props.FloatProperty(name='ValueShift', default=0.0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=5, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_PositionScale','m_PositionShift','m_ValueScale','m_ValueShift',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKPiecewiseFunctionShiftScale )        
TYPENAMES.append('VTKPiecewiseFunctionShiftScaleType' )

#--------------------------------------------------------------
class VTKPlaneCutter(Node, BVTK_Node):

    bl_idname = 'VTKPlaneCutterType'
    bl_label  = 'vtkPlaneCutter'
    
    m_BuildHierarchy: bpy.props.BoolProperty(name='BuildHierarchy', default=True, update=BVTK_Node.outdate_vtk_status)
    m_BuildTree: bpy.props.BoolProperty(name='BuildTree', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ComputeNormals: bpy.props.BoolProperty(name='ComputeNormals', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GeneratePolygons: bpy.props.BoolProperty(name='GeneratePolygons', default=True, update=BVTK_Node.outdate_vtk_status)
    m_InterpolateAttributes: bpy.props.BoolProperty(name='InterpolateAttributes', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=6, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_BuildHierarchy','m_BuildTree','m_ComputeNormals','m_GeneratePolygons','m_InterpolateAttributes','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], ['Plane'], []) 
    
add_class( VTKPlaneCutter )        
TYPENAMES.append('VTKPlaneCutterType' )

#--------------------------------------------------------------
class VTKPointConnectivityFilter(Node, BVTK_Node):

    bl_idname = 'VTKPointConnectivityFilterType'
    bl_label  = 'vtkPointConnectivityFilter'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKPointConnectivityFilter )        
TYPENAMES.append('VTKPointConnectivityFilterType' )

#--------------------------------------------------------------
class VTKPointDataToCellData(Node, BVTK_Node):

    bl_idname = 'VTKPointDataToCellDataType'
    bl_label  = 'vtkPointDataToCellData'
    
    m_CategoricalData: bpy.props.BoolProperty(name='CategoricalData', default=False, update=BVTK_Node.outdate_vtk_status)
    m_PassPointData: bpy.props.BoolProperty(name='PassPointData', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ProcessAllArrays: bpy.props.BoolProperty(name='ProcessAllArrays', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=4, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_CategoricalData','m_PassPointData','m_ProcessAllArrays','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKPointDataToCellData )        
TYPENAMES.append('VTKPointDataToCellDataType' )

#--------------------------------------------------------------
class VTKPointDensityFilter(Node, BVTK_Node):

    bl_idname = 'VTKPointDensityFilterType'
    bl_label  = 'vtkPointDensityFilter'
    e_DensityEstimate_items=[ (x,x,x) for x in ['FixedRadius', 'RelativeRadius']]
    e_DensityForm_items=[ (x,x,x) for x in ['VolumeNormalized', 'NumberOfPoints']]
    
    m_ComputeGradient: bpy.props.BoolProperty(name='ComputeGradient', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ScalarWeighting: bpy.props.BoolProperty(name='ScalarWeighting', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_AdjustDistance: bpy.props.FloatProperty(name='AdjustDistance', default=0.1, update=BVTK_Node.outdate_vtk_status)
    m_Radius: bpy.props.FloatProperty(name='Radius', default=1.0, update=BVTK_Node.outdate_vtk_status)
    m_RelativeRadius: bpy.props.FloatProperty(name='RelativeRadius', default=1.0, update=BVTK_Node.outdate_vtk_status)
    e_DensityEstimate: bpy.props.EnumProperty(name='DensityEstimate', default="RelativeRadius", items=e_DensityEstimate_items, update=BVTK_Node.outdate_vtk_status)
    e_DensityForm: bpy.props.EnumProperty(name='DensityForm', default="NumberOfPoints", items=e_DensityForm_items, update=BVTK_Node.outdate_vtk_status)
    m_SampleDimensions: bpy.props.IntVectorProperty(name='SampleDimensions', default=[100, 100, 100], size=3, update=BVTK_Node.outdate_vtk_status)
    m_ModelBounds: bpy.props.FloatVectorProperty(name='ModelBounds', default=[0.0, 0.0, 0.0, 0.0, 0.0, 0.0], size=6, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=10, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ComputeGradient','m_ScalarWeighting','m_ObjectName','m_AdjustDistance','m_Radius','m_RelativeRadius','e_DensityEstimate','e_DensityForm','m_SampleDimensions','m_ModelBounds',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKPointDensityFilter )        
TYPENAMES.append('VTKPointDensityFilterType' )

#--------------------------------------------------------------
class VTKPointOccupancyFilter(Node, BVTK_Node):

    bl_idname = 'VTKPointOccupancyFilterType'
    bl_label  = 'vtkPointOccupancyFilter'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_EmptyValue: bpy.props.IntProperty(name='EmptyValue', default=0, update=BVTK_Node.outdate_vtk_status)
    m_OccupiedValue: bpy.props.IntProperty(name='OccupiedValue', default=1, update=BVTK_Node.outdate_vtk_status)
    m_SampleDimensions: bpy.props.IntVectorProperty(name='SampleDimensions', default=[100, 100, 100], size=3, update=BVTK_Node.outdate_vtk_status)
    m_ModelBounds: bpy.props.FloatVectorProperty(name='ModelBounds', default=[0.0, 0.0, 0.0, 0.0, 0.0, 0.0], size=6, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=5, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_EmptyValue','m_OccupiedValue','m_SampleDimensions','m_ModelBounds',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKPointOccupancyFilter )        
TYPENAMES.append('VTKPointOccupancyFilterType' )

#--------------------------------------------------------------
class VTKPointSetAlgorithm(Node, BVTK_Node):

    bl_idname = 'VTKPointSetAlgorithmType'
    bl_label  = 'vtkPointSetAlgorithm'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKPointSetAlgorithm )        
TYPENAMES.append('VTKPointSetAlgorithmType' )

#--------------------------------------------------------------
class VTKPointSetToLabelHierarchy(Node, BVTK_Node):

    bl_idname = 'VTKPointSetToLabelHierarchyType'
    bl_label  = 'vtkPointSetToLabelHierarchy'
    
    m_BoundedSizeArrayName: bpy.props.StringProperty(name='BoundedSizeArrayName', default="BoundedSize", update=BVTK_Node.outdate_vtk_status)
    m_IconIndexArrayName: bpy.props.StringProperty(name='IconIndexArrayName', default="IconIndex", update=BVTK_Node.outdate_vtk_status)
    m_LabelArrayName: bpy.props.StringProperty(name='LabelArrayName', default="LabelText", update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_OrientationArrayName: bpy.props.StringProperty(name='OrientationArrayName', default="Orientation", update=BVTK_Node.outdate_vtk_status)
    m_PriorityArrayName: bpy.props.StringProperty(name='PriorityArrayName', default="Priority", update=BVTK_Node.outdate_vtk_status)
    m_SizeArrayName: bpy.props.StringProperty(name='SizeArrayName', default="LabelSize", update=BVTK_Node.outdate_vtk_status)
    m_MaximumDepth: bpy.props.IntProperty(name='MaximumDepth', default=5, update=BVTK_Node.outdate_vtk_status)
    m_TargetLabelCount: bpy.props.IntProperty(name='TargetLabelCount', default=32, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=9, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_BoundedSizeArrayName','m_IconIndexArrayName','m_LabelArrayName','m_ObjectName','m_OrientationArrayName','m_PriorityArrayName','m_SizeArrayName','m_MaximumDepth','m_TargetLabelCount',]
    def m_connections( self ):
        return (['input'], ['output'], ['TextProperty'], []) 
    
add_class( VTKPointSetToLabelHierarchy )        
TYPENAMES.append('VTKPointSetToLabelHierarchyType' )

#--------------------------------------------------------------
class VTKPointSetToMoleculeFilter(Node, BVTK_Node):

    bl_idname = 'VTKPointSetToMoleculeFilterType'
    bl_label  = 'vtkPointSetToMoleculeFilter'
    
    m_ConvertLinesIntoBonds: bpy.props.BoolProperty(name='ConvertLinesIntoBonds', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ConvertLinesIntoBonds','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKPointSetToMoleculeFilter )        
TYPENAMES.append('VTKPointSetToMoleculeFilterType' )

#--------------------------------------------------------------
class VTKPointSmoothingFilter(Node, BVTK_Node):

    bl_idname = 'VTKPointSmoothingFilterType'
    bl_label  = 'vtkPointSmoothingFilter'
    e_MotionConstraint_items=[ (x,x,x) for x in ['Unconstrained', 'Plane']]
    e_SmoothingMode_items=[ (x,x,x) for x in ['Default', 'Geometric', 'Uniform', 'Scalars', 'Tensors', 'FrameField']]
    
    m_ComputePackingRadius: bpy.props.BoolProperty(name='ComputePackingRadius', default=True, update=BVTK_Node.outdate_vtk_status)
    m_EnableConstraints: bpy.props.BoolProperty(name='EnableConstraints', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GenerateConstraintNormals: bpy.props.BoolProperty(name='GenerateConstraintNormals', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GenerateConstraintScalars: bpy.props.BoolProperty(name='GenerateConstraintScalars', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_NeighborhoodSize: bpy.props.IntProperty(name='NeighborhoodSize', default=8, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfIterations: bpy.props.IntProperty(name='NumberOfIterations', default=20, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfSubIterations: bpy.props.IntProperty(name='NumberOfSubIterations', default=10, update=BVTK_Node.outdate_vtk_status)
    m_AttractionFactor: bpy.props.FloatProperty(name='AttractionFactor', default=0.5, update=BVTK_Node.outdate_vtk_status)
    m_BoundaryAngle: bpy.props.FloatProperty(name='BoundaryAngle', default=110.0, update=BVTK_Node.outdate_vtk_status)
    m_Convergence: bpy.props.FloatProperty(name='Convergence', default=0.0, update=BVTK_Node.outdate_vtk_status)
    m_FixedAngle: bpy.props.FloatProperty(name='FixedAngle', default=60.0, update=BVTK_Node.outdate_vtk_status)
    m_MaximumStepSize: bpy.props.FloatProperty(name='MaximumStepSize', default=0.01, update=BVTK_Node.outdate_vtk_status)
    m_PackingFactor: bpy.props.FloatProperty(name='PackingFactor', default=1.0, update=BVTK_Node.outdate_vtk_status)
    m_PackingRadius: bpy.props.FloatProperty(name='PackingRadius', default=1.0, update=BVTK_Node.outdate_vtk_status)
    e_MotionConstraint: bpy.props.EnumProperty(name='MotionConstraint', default="Unconstrained", items=e_MotionConstraint_items, update=BVTK_Node.outdate_vtk_status)
    e_SmoothingMode: bpy.props.EnumProperty(name='SmoothingMode', default="Default", items=e_SmoothingMode_items, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=17, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ComputePackingRadius','m_EnableConstraints','m_GenerateConstraintNormals','m_GenerateConstraintScalars','m_ObjectName','m_NeighborhoodSize','m_NumberOfIterations','m_NumberOfSubIterations','m_AttractionFactor','m_BoundaryAngle','m_Convergence','m_FixedAngle','m_MaximumStepSize','m_PackingFactor','m_PackingRadius','e_MotionConstraint','e_SmoothingMode',]
    def m_connections( self ):
        return (['input'], ['output'], ['FrameFieldArray', 'Plane'], []) 
    
add_class( VTKPointSmoothingFilter )        
TYPENAMES.append('VTKPointSmoothingFilterType' )

#--------------------------------------------------------------
class VTKPoissonDiskSampler(Node, BVTK_Node):

    bl_idname = 'VTKPoissonDiskSamplerType'
    bl_label  = 'vtkPoissonDiskSampler'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_Radius: bpy.props.FloatProperty(name='Radius', default=1.0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_Radius',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKPoissonDiskSampler )        
TYPENAMES.append('VTKPoissonDiskSamplerType' )

#--------------------------------------------------------------
class VTKPolyDataAlgorithm(Node, BVTK_Node):

    bl_idname = 'VTKPolyDataAlgorithmType'
    bl_label  = 'vtkPolyDataAlgorithm'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKPolyDataAlgorithm )        
TYPENAMES.append('VTKPolyDataAlgorithmType' )

#--------------------------------------------------------------
class VTKPolyDataConnectivityFilter(Node, BVTK_Node):

    bl_idname = 'VTKPolyDataConnectivityFilterType'
    bl_label  = 'vtkPolyDataConnectivityFilter'
    e_ExtractionMode_items=[ (x,x,x) for x in ['PointSeededRegions', 'CellSeededRegions', 'SpecifiedRegions', 'LargestRegion', 'AllRegions', 'ClosestPointRegion']]
    
    m_ColorRegions: bpy.props.BoolProperty(name='ColorRegions', default=True, update=BVTK_Node.outdate_vtk_status)
    m_FullScalarConnectivity: bpy.props.BoolProperty(name='FullScalarConnectivity', default=True, update=BVTK_Node.outdate_vtk_status)
    m_MarkVisitedPointIds: bpy.props.BoolProperty(name='MarkVisitedPointIds', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ScalarConnectivity: bpy.props.BoolProperty(name='ScalarConnectivity', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    e_ExtractionMode: bpy.props.EnumProperty(name='ExtractionMode', default="LargestRegion", items=e_ExtractionMode_items, update=BVTK_Node.outdate_vtk_status)
    m_ClosestPoint: bpy.props.FloatVectorProperty(name='ClosestPoint', default=[0.0, 0.0, 0.0], size=3, update=BVTK_Node.outdate_vtk_status)
    m_ScalarRange: bpy.props.FloatVectorProperty(name='ScalarRange', default=[0.0, 1.0], size=2, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=8, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ColorRegions','m_FullScalarConnectivity','m_MarkVisitedPointIds','m_ScalarConnectivity','m_ObjectName','e_ExtractionMode','m_ClosestPoint','m_ScalarRange',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKPolyDataConnectivityFilter )        
TYPENAMES.append('VTKPolyDataConnectivityFilterType' )

#--------------------------------------------------------------
class VTKPolyDataNormals(Node, BVTK_Node):

    bl_idname = 'VTKPolyDataNormalsType'
    bl_label  = 'vtkPolyDataNormals'
    
    m_AutoOrientNormals: bpy.props.BoolProperty(name='AutoOrientNormals', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ComputeCellNormals: bpy.props.BoolProperty(name='ComputeCellNormals', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ComputePointNormals: bpy.props.BoolProperty(name='ComputePointNormals', default=True, update=BVTK_Node.outdate_vtk_status)
    m_Consistency: bpy.props.BoolProperty(name='Consistency', default=True, update=BVTK_Node.outdate_vtk_status)
    m_FlipNormals: bpy.props.BoolProperty(name='FlipNormals', default=True, update=BVTK_Node.outdate_vtk_status)
    m_NonManifoldTraversal: bpy.props.BoolProperty(name='NonManifoldTraversal', default=True, update=BVTK_Node.outdate_vtk_status)
    m_Splitting: bpy.props.BoolProperty(name='Splitting', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_FeatureAngle: bpy.props.FloatProperty(name='FeatureAngle', default=30.0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=9, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_AutoOrientNormals','m_ComputeCellNormals','m_ComputePointNormals','m_Consistency','m_FlipNormals','m_NonManifoldTraversal','m_Splitting','m_ObjectName','m_FeatureAngle',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKPolyDataNormals )        
TYPENAMES.append('VTKPolyDataNormalsType' )

#--------------------------------------------------------------
class VTKPolyDataPlaneCutter(Node, BVTK_Node):

    bl_idname = 'VTKPolyDataPlaneCutterType'
    bl_label  = 'vtkPolyDataPlaneCutter'
    
    m_ComputeNormals: bpy.props.BoolProperty(name='ComputeNormals', default=False, update=BVTK_Node.outdate_vtk_status)
    m_InterpolateAttributes: bpy.props.BoolProperty(name='InterpolateAttributes', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_BatchSize: bpy.props.IntProperty(name='BatchSize', default=10000, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=4, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ComputeNormals','m_InterpolateAttributes','m_ObjectName','m_BatchSize',]
    def m_connections( self ):
        return (['input'], ['output'], ['Plane'], []) 
    
add_class( VTKPolyDataPlaneCutter )        
TYPENAMES.append('VTKPolyDataPlaneCutterType' )

#--------------------------------------------------------------
class VTKPolyDataPointSampler(Node, BVTK_Node):

    bl_idname = 'VTKPolyDataPointSamplerType'
    bl_label  = 'vtkPolyDataPointSampler'
    e_PointGenerationMode_items=[ (x,x,x) for x in ['Regular', 'Random']]
    
    m_GenerateEdgePoints: bpy.props.BoolProperty(name='GenerateEdgePoints', default=True, update=BVTK_Node.outdate_vtk_status)
    m_GenerateInteriorPoints: bpy.props.BoolProperty(name='GenerateInteriorPoints', default=True, update=BVTK_Node.outdate_vtk_status)
    m_GenerateVertexPoints: bpy.props.BoolProperty(name='GenerateVertexPoints', default=True, update=BVTK_Node.outdate_vtk_status)
    m_GenerateVertices: bpy.props.BoolProperty(name='GenerateVertices', default=True, update=BVTK_Node.outdate_vtk_status)
    m_InterpolatePointData: bpy.props.BoolProperty(name='InterpolatePointData', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_Distance: bpy.props.FloatProperty(name='Distance', default=0.01, update=BVTK_Node.outdate_vtk_status)
    e_PointGenerationMode: bpy.props.EnumProperty(name='PointGenerationMode', default="Regular", items=e_PointGenerationMode_items, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=8, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_GenerateEdgePoints','m_GenerateInteriorPoints','m_GenerateVertexPoints','m_GenerateVertices','m_InterpolatePointData','m_ObjectName','m_Distance','e_PointGenerationMode',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKPolyDataPointSampler )        
TYPENAMES.append('VTKPolyDataPointSamplerType' )

#--------------------------------------------------------------
class VTKPolyDataSilhouette(Node, BVTK_Node):

    bl_idname = 'VTKPolyDataSilhouetteType'
    bl_label  = 'vtkPolyDataSilhouette'
    e_Direction_items=[ (x,x,x) for x in ['SpecifiedVector', 'SpecifiedOrigin', 'CameraOrigin', 'CameraVector']]
    
    m_BorderEdges: bpy.props.BoolProperty(name='BorderEdges', default=True, update=BVTK_Node.outdate_vtk_status)
    m_PieceInvariant: bpy.props.BoolProperty(name='PieceInvariant', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_EnableFeatureAngle: bpy.props.IntProperty(name='EnableFeatureAngle', default=1, update=BVTK_Node.outdate_vtk_status)
    m_FeatureAngle: bpy.props.FloatProperty(name='FeatureAngle', default=60.0, update=BVTK_Node.outdate_vtk_status)
    e_Direction: bpy.props.EnumProperty(name='Direction', default="CameraOrigin", items=e_Direction_items, update=BVTK_Node.outdate_vtk_status)
    m_Origin: bpy.props.FloatVectorProperty(name='Origin', default=[0.0, 0.0, 0.0], size=3, update=BVTK_Node.outdate_vtk_status)
    m_Vector: bpy.props.FloatVectorProperty(name='Vector', default=[0.0, 0.0, 0.0], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=8, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_BorderEdges','m_PieceInvariant','m_ObjectName','m_EnableFeatureAngle','m_FeatureAngle','e_Direction','m_Origin','m_Vector',]
    def m_connections( self ):
        return (['input'], ['output'], ['Prop3D'], []) 
    
add_class( VTKPolyDataSilhouette )        
TYPENAMES.append('VTKPolyDataSilhouetteType' )

#--------------------------------------------------------------
class VTKPolyDataStreamer(Node, BVTK_Node):

    bl_idname = 'VTKPolyDataStreamerType'
    bl_label  = 'vtkPolyDataStreamer'
    
    m_ColorByPiece: bpy.props.BoolProperty(name='ColorByPiece', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_NumberOfStreamDivisions: bpy.props.IntProperty(name='NumberOfStreamDivisions', default=2, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=3, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ColorByPiece','m_ObjectName','m_NumberOfStreamDivisions',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKPolyDataStreamer )        
TYPENAMES.append('VTKPolyDataStreamerType' )

#--------------------------------------------------------------
class VTKPolyDataTangents(Node, BVTK_Node):

    bl_idname = 'VTKPolyDataTangentsType'
    bl_label  = 'vtkPolyDataTangents'
    
    m_ComputeCellTangents: bpy.props.BoolProperty(name='ComputeCellTangents', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ComputePointTangents: bpy.props.BoolProperty(name='ComputePointTangents', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=3, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ComputeCellTangents','m_ComputePointTangents','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKPolyDataTangents )        
TYPENAMES.append('VTKPolyDataTangentsType' )

#--------------------------------------------------------------
class VTKPolyDataToImageStencil(Node, BVTK_Node):

    bl_idname = 'VTKPolyDataToImageStencilType'
    bl_label  = 'vtkPolyDataToImageStencil'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_Tolerance: bpy.props.FloatProperty(name='Tolerance', default=7.62939453125e-06, update=BVTK_Node.outdate_vtk_status)
    m_OutputWholeExtent: bpy.props.IntVectorProperty(name='OutputWholeExtent', default=[0, -1, 0, -1, 0, -1], size=6, update=BVTK_Node.outdate_vtk_status)
    m_OutputOrigin: bpy.props.FloatVectorProperty(name='OutputOrigin', default=[0.0, 0.0, 0.0], size=3, update=BVTK_Node.outdate_vtk_status)
    m_OutputSpacing: bpy.props.FloatVectorProperty(name='OutputSpacing', default=[1.0, 1.0, 1.0], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=5, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_Tolerance','m_OutputWholeExtent','m_OutputOrigin','m_OutputSpacing',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKPolyDataToImageStencil )        
TYPENAMES.append('VTKPolyDataToImageStencilType' )

#--------------------------------------------------------------
class VTKPolyDataToReebGraphFilter(Node, BVTK_Node):

    bl_idname = 'VTKPolyDataToReebGraphFilterType'
    bl_label  = 'vtkPolyDataToReebGraphFilter'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_FieldId: bpy.props.IntProperty(name='FieldId', default=0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_FieldId',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKPolyDataToReebGraphFilter )        
TYPENAMES.append('VTKPolyDataToReebGraphFilterType' )

#--------------------------------------------------------------
class VTKProcessIdScalars(Node, BVTK_Node):

    bl_idname = 'VTKProcessIdScalarsType'
    bl_label  = 'vtkProcessIdScalars'
    
    m_RandomMode: bpy.props.BoolProperty(name='RandomMode', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_RandomMode','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKProcessIdScalars )        
TYPENAMES.append('VTKProcessIdScalarsType' )

#--------------------------------------------------------------
class VTKProcrustesAlignmentFilter(Node, BVTK_Node):

    bl_idname = 'VTKProcrustesAlignmentFilterType'
    bl_label  = 'vtkProcrustesAlignmentFilter'
    
    m_StartFromCentroid: bpy.props.BoolProperty(name='StartFromCentroid', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_StartFromCentroid','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKProcrustesAlignmentFilter )        
TYPENAMES.append('VTKProcrustesAlignmentFilterType' )

#--------------------------------------------------------------
class VTKProgrammableAttributeDataFilter(Node, BVTK_Node):

    bl_idname = 'VTKProgrammableAttributeDataFilterType'
    bl_label  = 'vtkProgrammableAttributeDataFilter'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKProgrammableAttributeDataFilter )        
TYPENAMES.append('VTKProgrammableAttributeDataFilterType' )

#--------------------------------------------------------------
class VTKProgrammableFilter(Node, BVTK_Node):

    bl_idname = 'VTKProgrammableFilterType'
    bl_label  = 'vtkProgrammableFilter'
    
    m_CopyArrays: bpy.props.BoolProperty(name='CopyArrays', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_CopyArrays','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKProgrammableFilter )        
TYPENAMES.append('VTKProgrammableFilterType' )

#--------------------------------------------------------------
class VTKProjectPointsToPlane(Node, BVTK_Node):

    bl_idname = 'VTKProjectPointsToPlaneType'
    bl_label  = 'vtkProjectPointsToPlane'
    e_ProjectionType_items=[ (x,x,x) for x in ['XPlane', 'YPlane', 'ZPlane', 'SpecifiedPlane', 'BestCoordinatePlane', 'BestFitPlane']]
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    e_ProjectionType: bpy.props.EnumProperty(name='ProjectionType', default="ZPlane", items=e_ProjectionType_items, update=BVTK_Node.outdate_vtk_status)
    m_Normal: bpy.props.FloatVectorProperty(name='Normal', default=[0.0, 0.0, 1.0], size=3, update=BVTK_Node.outdate_vtk_status)
    m_Origin: bpy.props.FloatVectorProperty(name='Origin', default=[0.0, 0.0, 0.0], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=4, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','e_ProjectionType','m_Normal','m_Origin',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKProjectPointsToPlane )        
TYPENAMES.append('VTKProjectPointsToPlaneType' )

#--------------------------------------------------------------
class VTKProjectSphereFilter(Node, BVTK_Node):

    bl_idname = 'VTKProjectSphereFilterType'
    bl_label  = 'vtkProjectSphereFilter'
    
    m_KeepPolePoints: bpy.props.BoolProperty(name='KeepPolePoints', default=False, update=BVTK_Node.outdate_vtk_status)
    m_TranslateZ: bpy.props.BoolProperty(name='TranslateZ', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_Center: bpy.props.FloatVectorProperty(name='Center', default=[0.0, 0.0, 0.0], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=4, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_KeepPolePoints','m_TranslateZ','m_ObjectName','m_Center',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKProjectSphereFilter )        
TYPENAMES.append('VTKProjectSphereFilterType' )

#--------------------------------------------------------------
class VTKProjectedTexture(Node, BVTK_Node):

    bl_idname = 'VTKProjectedTextureType'
    bl_label  = 'vtkProjectedTexture'
    e_CameraMode_items=[ (x,x,x) for x in ['Pinhole', 'TwoMirror']]
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_MirrorSeparation: bpy.props.FloatProperty(name='MirrorSeparation', default=1.0, update=BVTK_Node.outdate_vtk_status)
    e_CameraMode: bpy.props.EnumProperty(name='CameraMode', default="Pinhole", items=e_CameraMode_items, update=BVTK_Node.outdate_vtk_status)
    m_AspectRatio: bpy.props.FloatVectorProperty(name='AspectRatio', default=[1.0, 1.0, 1.0], size=3, update=BVTK_Node.outdate_vtk_status)
    m_Position: bpy.props.FloatVectorProperty(name='Position', default=[0.0, 0.0, 1.0], size=3, update=BVTK_Node.outdate_vtk_status)
    m_SRange: bpy.props.FloatVectorProperty(name='SRange', default=[0.0, 1.0], size=2, update=BVTK_Node.outdate_vtk_status)
    m_TRange: bpy.props.FloatVectorProperty(name='TRange', default=[0.0, 1.0], size=2, update=BVTK_Node.outdate_vtk_status)
    m_Up: bpy.props.FloatVectorProperty(name='Up', default=[0.0, 1.0, 0.0], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=8, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_MirrorSeparation','e_CameraMode','m_AspectRatio','m_Position','m_SRange','m_TRange','m_Up',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKProjectedTexture )        
TYPENAMES.append('VTKProjectedTextureType' )

#--------------------------------------------------------------
class VTKProteinRibbonFilter(Node, BVTK_Node):

    bl_idname = 'VTKProteinRibbonFilterType'
    bl_label  = 'vtkProteinRibbonFilter'
    
    m_DrawSmallMoleculesAsSpheres: bpy.props.BoolProperty(name='DrawSmallMoleculesAsSpheres', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_SphereResolution: bpy.props.IntProperty(name='SphereResolution', default=20, update=BVTK_Node.outdate_vtk_status)
    m_SubdivideFactor: bpy.props.IntProperty(name='SubdivideFactor', default=20, update=BVTK_Node.outdate_vtk_status)
    m_CoilWidth: bpy.props.FloatProperty(name='CoilWidth', default=0.30000001192092896, update=BVTK_Node.outdate_vtk_status)
    m_HelixWidth: bpy.props.FloatProperty(name='HelixWidth', default=1.2999999523162842, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=6, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_DrawSmallMoleculesAsSpheres','m_ObjectName','m_SphereResolution','m_SubdivideFactor','m_CoilWidth','m_HelixWidth',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKProteinRibbonFilter )        
TYPENAMES.append('VTKProteinRibbonFilterType' )

#--------------------------------------------------------------
class VTKQuadRotationalExtrusionFilter(Node, BVTK_Node):

    bl_idname = 'VTKQuadRotationalExtrusionFilterType'
    bl_label  = 'vtkQuadRotationalExtrusionFilter'
    e_Axis_items=[ (x,x,x) for x in ['X', 'Y', 'Z']]
    
    m_Capping: bpy.props.BoolProperty(name='Capping', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_Resolution: bpy.props.IntProperty(name='Resolution', default=12, update=BVTK_Node.outdate_vtk_status)
    m_DefaultAngle: bpy.props.FloatProperty(name='DefaultAngle', default=360.0, update=BVTK_Node.outdate_vtk_status)
    m_DeltaRadius: bpy.props.FloatProperty(name='DeltaRadius', default=0.0, update=BVTK_Node.outdate_vtk_status)
    m_Translation: bpy.props.FloatProperty(name='Translation', default=0.0, update=BVTK_Node.outdate_vtk_status)
    e_Axis: bpy.props.EnumProperty(name='Axis', default="Z", items=e_Axis_items, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=7, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_Capping','m_ObjectName','m_Resolution','m_DefaultAngle','m_DeltaRadius','m_Translation','e_Axis',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKQuadRotationalExtrusionFilter )        
TYPENAMES.append('VTKQuadRotationalExtrusionFilterType' )

#--------------------------------------------------------------
class VTKQuadraturePointInterpolator(Node, BVTK_Node):

    bl_idname = 'VTKQuadraturePointInterpolatorType'
    bl_label  = 'vtkQuadraturePointInterpolator'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKQuadraturePointInterpolator )        
TYPENAMES.append('VTKQuadraturePointInterpolatorType' )

#--------------------------------------------------------------
class VTKQuadraturePointsGenerator(Node, BVTK_Node):

    bl_idname = 'VTKQuadraturePointsGeneratorType'
    bl_label  = 'vtkQuadraturePointsGenerator'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKQuadraturePointsGenerator )        
TYPENAMES.append('VTKQuadraturePointsGeneratorType' )

#--------------------------------------------------------------
class VTKQuadratureSchemeDictionaryGenerator(Node, BVTK_Node):

    bl_idname = 'VTKQuadratureSchemeDictionaryGeneratorType'
    bl_label  = 'vtkQuadratureSchemeDictionaryGenerator'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKQuadratureSchemeDictionaryGenerator )        
TYPENAMES.append('VTKQuadratureSchemeDictionaryGeneratorType' )

#--------------------------------------------------------------
class VTKQuadricClustering(Node, BVTK_Node):

    bl_idname = 'VTKQuadricClusteringType'
    bl_label  = 'vtkQuadricClustering'
    
    m_AutoAdjustNumberOfDivisions: bpy.props.BoolProperty(name='AutoAdjustNumberOfDivisions', default=True, update=BVTK_Node.outdate_vtk_status)
    m_CopyCellData: bpy.props.BoolProperty(name='CopyCellData', default=True, update=BVTK_Node.outdate_vtk_status)
    m_PreventDuplicateCells: bpy.props.BoolProperty(name='PreventDuplicateCells', default=True, update=BVTK_Node.outdate_vtk_status)
    m_UseFeatureEdges: bpy.props.BoolProperty(name='UseFeatureEdges', default=True, update=BVTK_Node.outdate_vtk_status)
    m_UseFeaturePoints: bpy.props.BoolProperty(name='UseFeaturePoints', default=True, update=BVTK_Node.outdate_vtk_status)
    m_UseInputPoints: bpy.props.BoolProperty(name='UseInputPoints', default=True, update=BVTK_Node.outdate_vtk_status)
    m_UseInternalTriangles: bpy.props.BoolProperty(name='UseInternalTriangles', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_NumberOfXDivisions: bpy.props.IntProperty(name='NumberOfXDivisions', default=50, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfYDivisions: bpy.props.IntProperty(name='NumberOfYDivisions', default=50, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfZDivisions: bpy.props.IntProperty(name='NumberOfZDivisions', default=50, update=BVTK_Node.outdate_vtk_status)
    m_FeaturePointsAngle: bpy.props.FloatProperty(name='FeaturePointsAngle', default=30.0, update=BVTK_Node.outdate_vtk_status)
    m_DivisionOrigin: bpy.props.FloatVectorProperty(name='DivisionOrigin', default=[0.0, 0.0, 0.0], size=3, update=BVTK_Node.outdate_vtk_status)
    m_DivisionSpacing: bpy.props.FloatVectorProperty(name='DivisionSpacing', default=[1.0, 1.0, 1.0], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=14, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_AutoAdjustNumberOfDivisions','m_CopyCellData','m_PreventDuplicateCells','m_UseFeatureEdges','m_UseFeaturePoints','m_UseInputPoints','m_UseInternalTriangles','m_ObjectName','m_NumberOfXDivisions','m_NumberOfYDivisions','m_NumberOfZDivisions','m_FeaturePointsAngle','m_DivisionOrigin','m_DivisionSpacing',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKQuadricClustering )        
TYPENAMES.append('VTKQuadricClusteringType' )

#--------------------------------------------------------------
class VTKQuadricDecimation(Node, BVTK_Node):

    bl_idname = 'VTKQuadricDecimationType'
    bl_label  = 'vtkQuadricDecimation'
    
    m_AttributeErrorMetric: bpy.props.BoolProperty(name='AttributeErrorMetric', default=True, update=BVTK_Node.outdate_vtk_status)
    m_NormalsAttribute: bpy.props.BoolProperty(name='NormalsAttribute', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ScalarsAttribute: bpy.props.BoolProperty(name='ScalarsAttribute', default=True, update=BVTK_Node.outdate_vtk_status)
    m_TCoordsAttribute: bpy.props.BoolProperty(name='TCoordsAttribute', default=True, update=BVTK_Node.outdate_vtk_status)
    m_TensorsAttribute: bpy.props.BoolProperty(name='TensorsAttribute', default=True, update=BVTK_Node.outdate_vtk_status)
    m_VectorsAttribute: bpy.props.BoolProperty(name='VectorsAttribute', default=True, update=BVTK_Node.outdate_vtk_status)
    m_VolumePreservation: bpy.props.BoolProperty(name='VolumePreservation', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_NormalsWeight: bpy.props.FloatProperty(name='NormalsWeight', default=0.1, update=BVTK_Node.outdate_vtk_status)
    m_ScalarsWeight: bpy.props.FloatProperty(name='ScalarsWeight', default=0.1, update=BVTK_Node.outdate_vtk_status)
    m_TCoordsWeight: bpy.props.FloatProperty(name='TCoordsWeight', default=0.1, update=BVTK_Node.outdate_vtk_status)
    m_TargetReduction: bpy.props.FloatProperty(name='TargetReduction', default=0.9, update=BVTK_Node.outdate_vtk_status)
    m_TensorsWeight: bpy.props.FloatProperty(name='TensorsWeight', default=0.1, update=BVTK_Node.outdate_vtk_status)
    m_VectorsWeight: bpy.props.FloatProperty(name='VectorsWeight', default=0.1, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=14, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_AttributeErrorMetric','m_NormalsAttribute','m_ScalarsAttribute','m_TCoordsAttribute','m_TensorsAttribute','m_VectorsAttribute','m_VolumePreservation','m_ObjectName','m_NormalsWeight','m_ScalarsWeight','m_TCoordsWeight','m_TargetReduction','m_TensorsWeight','m_VectorsWeight',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKQuadricDecimation )        
TYPENAMES.append('VTKQuadricDecimationType' )

#--------------------------------------------------------------
class VTKQuantizePolyDataPoints(Node, BVTK_Node):

    bl_idname = 'VTKQuantizePolyDataPointsType'
    bl_label  = 'vtkQuantizePolyDataPoints'
    
    m_ConvertLinesToPoints: bpy.props.BoolProperty(name='ConvertLinesToPoints', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ConvertPolysToLines: bpy.props.BoolProperty(name='ConvertPolysToLines', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ConvertStripsToPolys: bpy.props.BoolProperty(name='ConvertStripsToPolys', default=True, update=BVTK_Node.outdate_vtk_status)
    m_PieceInvariant: bpy.props.BoolProperty(name='PieceInvariant', default=True, update=BVTK_Node.outdate_vtk_status)
    m_PointMerging: bpy.props.BoolProperty(name='PointMerging', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ToleranceIsAbsolute: bpy.props.BoolProperty(name='ToleranceIsAbsolute', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_AbsoluteTolerance: bpy.props.FloatProperty(name='AbsoluteTolerance', default=1.0, update=BVTK_Node.outdate_vtk_status)
    m_QFactor: bpy.props.FloatProperty(name='QFactor', default=0.25, update=BVTK_Node.outdate_vtk_status)
    m_Tolerance: bpy.props.FloatProperty(name='Tolerance', default=0.0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=10, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ConvertLinesToPoints','m_ConvertPolysToLines','m_ConvertStripsToPolys','m_PieceInvariant','m_PointMerging','m_ToleranceIsAbsolute','m_ObjectName','m_AbsoluteTolerance','m_QFactor','m_Tolerance',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKQuantizePolyDataPoints )        
TYPENAMES.append('VTKQuantizePolyDataPointsType' )

#--------------------------------------------------------------
class VTKRandomAttributeGenerator(Node, BVTK_Node):

    bl_idname = 'VTKRandomAttributeGeneratorType'
    bl_label  = 'vtkRandomAttributeGenerator'
    
    m_AttributesConstantPerBlock: bpy.props.BoolProperty(name='AttributesConstantPerBlock', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GenerateCellArray: bpy.props.BoolProperty(name='GenerateCellArray', default=True, update=BVTK_Node.outdate_vtk_status)
    m_GenerateCellNormals: bpy.props.BoolProperty(name='GenerateCellNormals', default=True, update=BVTK_Node.outdate_vtk_status)
    m_GenerateCellScalars: bpy.props.BoolProperty(name='GenerateCellScalars', default=True, update=BVTK_Node.outdate_vtk_status)
    m_GenerateCellTCoords: bpy.props.BoolProperty(name='GenerateCellTCoords', default=True, update=BVTK_Node.outdate_vtk_status)
    m_GenerateCellTensors: bpy.props.BoolProperty(name='GenerateCellTensors', default=True, update=BVTK_Node.outdate_vtk_status)
    m_GenerateCellVectors: bpy.props.BoolProperty(name='GenerateCellVectors', default=True, update=BVTK_Node.outdate_vtk_status)
    m_GenerateFieldArray: bpy.props.BoolProperty(name='GenerateFieldArray', default=True, update=BVTK_Node.outdate_vtk_status)
    m_GeneratePointArray: bpy.props.BoolProperty(name='GeneratePointArray', default=True, update=BVTK_Node.outdate_vtk_status)
    m_GeneratePointNormals: bpy.props.BoolProperty(name='GeneratePointNormals', default=True, update=BVTK_Node.outdate_vtk_status)
    m_GeneratePointScalars: bpy.props.BoolProperty(name='GeneratePointScalars', default=True, update=BVTK_Node.outdate_vtk_status)
    m_GeneratePointTCoords: bpy.props.BoolProperty(name='GeneratePointTCoords', default=True, update=BVTK_Node.outdate_vtk_status)
    m_GeneratePointTensors: bpy.props.BoolProperty(name='GeneratePointTensors', default=True, update=BVTK_Node.outdate_vtk_status)
    m_GeneratePointVectors: bpy.props.BoolProperty(name='GeneratePointVectors', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_NumberOfComponents: bpy.props.IntProperty(name='NumberOfComponents', default=1, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfTuples: bpy.props.IntProperty(name='NumberOfTuples', default=0, update=BVTK_Node.outdate_vtk_status)
    m_MaximumComponentValue: bpy.props.FloatProperty(name='MaximumComponentValue', default=1.0, update=BVTK_Node.outdate_vtk_status)
    m_MinimumComponentValue: bpy.props.FloatProperty(name='MinimumComponentValue', default=0.0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=19, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_AttributesConstantPerBlock','m_GenerateCellArray','m_GenerateCellNormals','m_GenerateCellScalars','m_GenerateCellTCoords','m_GenerateCellTensors','m_GenerateCellVectors','m_GenerateFieldArray','m_GeneratePointArray','m_GeneratePointNormals','m_GeneratePointScalars','m_GeneratePointTCoords','m_GeneratePointTensors','m_GeneratePointVectors','m_ObjectName','m_NumberOfComponents','m_NumberOfTuples','m_MaximumComponentValue','m_MinimumComponentValue',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKRandomAttributeGenerator )        
TYPENAMES.append('VTKRandomAttributeGeneratorType' )

#--------------------------------------------------------------
class VTKRearrangeFields(Node, BVTK_Node):

    bl_idname = 'VTKRearrangeFieldsType'
    bl_label  = 'vtkRearrangeFields'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKRearrangeFields )        
TYPENAMES.append('VTKRearrangeFieldsType' )

#--------------------------------------------------------------
class VTKRectilinearGridAlgorithm(Node, BVTK_Node):

    bl_idname = 'VTKRectilinearGridAlgorithmType'
    bl_label  = 'vtkRectilinearGridAlgorithm'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKRectilinearGridAlgorithm )        
TYPENAMES.append('VTKRectilinearGridAlgorithmType' )

#--------------------------------------------------------------
class VTKRectilinearGridClip(Node, BVTK_Node):

    bl_idname = 'VTKRectilinearGridClipType'
    bl_label  = 'vtkRectilinearGridClip'
    
    m_ClipData: bpy.props.BoolProperty(name='ClipData', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ClipData','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKRectilinearGridClip )        
TYPENAMES.append('VTKRectilinearGridClipType' )

#--------------------------------------------------------------
class VTKRectilinearGridGeometryFilter(Node, BVTK_Node):

    bl_idname = 'VTKRectilinearGridGeometryFilterType'
    bl_label  = 'vtkRectilinearGridGeometryFilter'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_Extent: bpy.props.IntVectorProperty(name='Extent', default=[0, 1000000000, 0, 1000000000, 0, 1000000000], size=6, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_Extent',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKRectilinearGridGeometryFilter )        
TYPENAMES.append('VTKRectilinearGridGeometryFilterType' )

#--------------------------------------------------------------
class VTKRectilinearGridOutlineFilter(Node, BVTK_Node):

    bl_idname = 'VTKRectilinearGridOutlineFilterType'
    bl_label  = 'vtkRectilinearGridOutlineFilter'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKRectilinearGridOutlineFilter )        
TYPENAMES.append('VTKRectilinearGridOutlineFilterType' )

#--------------------------------------------------------------
class VTKRectilinearGridPartitioner(Node, BVTK_Node):

    bl_idname = 'VTKRectilinearGridPartitionerType'
    bl_label  = 'vtkRectilinearGridPartitioner'
    
    m_DuplicateNodes: bpy.props.BoolProperty(name='DuplicateNodes', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_NumberOfGhostLayers: bpy.props.IntProperty(name='NumberOfGhostLayers', default=0, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfPartitions: bpy.props.IntProperty(name='NumberOfPartitions', default=2, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=4, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_DuplicateNodes','m_ObjectName','m_NumberOfGhostLayers','m_NumberOfPartitions',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKRectilinearGridPartitioner )        
TYPENAMES.append('VTKRectilinearGridPartitionerType' )

#--------------------------------------------------------------
class VTKRectilinearGridToPointSet(Node, BVTK_Node):

    bl_idname = 'VTKRectilinearGridToPointSetType'
    bl_label  = 'vtkRectilinearGridToPointSet'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKRectilinearGridToPointSet )        
TYPENAMES.append('VTKRectilinearGridToPointSetType' )

#--------------------------------------------------------------
class VTKRectilinearGridToTetrahedra(Node, BVTK_Node):

    bl_idname = 'VTKRectilinearGridToTetrahedraType'
    bl_label  = 'vtkRectilinearGridToTetrahedra'
    e_TetraPerCell_items=[ (x,x,x) for x in ['5And12', '5', '6', '12']]
    
    m_RememberVoxelId: bpy.props.BoolProperty(name='RememberVoxelId', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    e_TetraPerCell: bpy.props.EnumProperty(name='TetraPerCell', default="5", items=e_TetraPerCell_items, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=3, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_RememberVoxelId','m_ObjectName','e_TetraPerCell',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKRectilinearGridToTetrahedra )        
TYPENAMES.append('VTKRectilinearGridToTetrahedraType' )

#--------------------------------------------------------------
class VTKRectilinearSynchronizedTemplates(Node, BVTK_Node):

    bl_idname = 'VTKRectilinearSynchronizedTemplatesType'
    bl_label  = 'vtkRectilinearSynchronizedTemplates'
    
    m_ComputeGradients: bpy.props.BoolProperty(name='ComputeGradients', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ComputeNormals: bpy.props.BoolProperty(name='ComputeNormals', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ComputeScalars: bpy.props.BoolProperty(name='ComputeScalars', default=True, update=BVTK_Node.outdate_vtk_status)
    m_GenerateTriangles: bpy.props.BoolProperty(name='GenerateTriangles', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_ArrayComponent: bpy.props.IntProperty(name='ArrayComponent', default=0, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfContours: bpy.props.IntProperty(name='NumberOfContours', default=1, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=7, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ComputeGradients','m_ComputeNormals','m_ComputeScalars','m_GenerateTriangles','m_ObjectName','m_ArrayComponent','m_NumberOfContours',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKRectilinearSynchronizedTemplates )        
TYPENAMES.append('VTKRectilinearSynchronizedTemplatesType' )

#--------------------------------------------------------------
class VTKRecursiveDividingCubes(Node, BVTK_Node):

    bl_idname = 'VTKRecursiveDividingCubesType'
    bl_label  = 'vtkRecursiveDividingCubes'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_Increment: bpy.props.IntProperty(name='Increment', default=1, update=BVTK_Node.outdate_vtk_status)
    m_Distance: bpy.props.FloatProperty(name='Distance', default=0.1, update=BVTK_Node.outdate_vtk_status)
    m_Value: bpy.props.FloatProperty(name='Value', default=0.0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=4, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_Increment','m_Distance','m_Value',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKRecursiveDividingCubes )        
TYPENAMES.append('VTKRecursiveDividingCubesType' )

#--------------------------------------------------------------
class VTKRedistributeDataSetFilter(Node, BVTK_Node):

    bl_idname = 'VTKRedistributeDataSetFilterType'
    bl_label  = 'vtkRedistributeDataSetFilter'
    e_BoundaryMode_items=[ (x,x,x) for x in ['AssignToOneRegion', 'AssignToAllIntersectingRegions', 'SplitBoundaryCells']]
    
    m_EnableDebugging: bpy.props.BoolProperty(name='EnableDebugging', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ExpandExplicitCuts: bpy.props.BoolProperty(name='ExpandExplicitCuts', default=True, update=BVTK_Node.outdate_vtk_status)
    m_GenerateGlobalCellIds: bpy.props.BoolProperty(name='GenerateGlobalCellIds', default=True, update=BVTK_Node.outdate_vtk_status)
    m_LoadBalanceAcrossAllBlocks: bpy.props.BoolProperty(name='LoadBalanceAcrossAllBlocks', default=True, update=BVTK_Node.outdate_vtk_status)
    m_PreservePartitionsInOutput: bpy.props.BoolProperty(name='PreservePartitionsInOutput', default=False, update=BVTK_Node.outdate_vtk_status)
    m_UseExplicitCuts: bpy.props.BoolProperty(name='UseExplicitCuts', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_NumberOfPartitions: bpy.props.IntProperty(name='NumberOfPartitions', default=0, update=BVTK_Node.outdate_vtk_status)
    e_BoundaryMode: bpy.props.EnumProperty(name='BoundaryMode', default="AssignToOneRegion", items=e_BoundaryMode_items, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=9, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_EnableDebugging','m_ExpandExplicitCuts','m_GenerateGlobalCellIds','m_LoadBalanceAcrossAllBlocks','m_PreservePartitionsInOutput','m_UseExplicitCuts','m_ObjectName','m_NumberOfPartitions','e_BoundaryMode',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKRedistributeDataSetFilter )        
TYPENAMES.append('VTKRedistributeDataSetFilterType' )

#--------------------------------------------------------------
class VTKReflectionFilter(Node, BVTK_Node):

    bl_idname = 'VTKReflectionFilterType'
    bl_label  = 'vtkReflectionFilter'
    e_Plane_items=[ (x,x,x) for x in ['XMin', 'YMin', 'ZMin', 'XMax', 'YMax', 'ZMax', 'X', 'Y', 'Z']]
    
    m_CopyInput: bpy.props.BoolProperty(name='CopyInput', default=True, update=BVTK_Node.outdate_vtk_status)
    m_FlipAllInputArrays: bpy.props.BoolProperty(name='FlipAllInputArrays', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_Center: bpy.props.FloatProperty(name='Center', default=0.0, update=BVTK_Node.outdate_vtk_status)
    e_Plane: bpy.props.EnumProperty(name='Plane', default="XMin", items=e_Plane_items, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=5, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_CopyInput','m_FlipAllInputArrays','m_ObjectName','m_Center','e_Plane',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKReflectionFilter )        
TYPENAMES.append('VTKReflectionFilterType' )

#--------------------------------------------------------------
class VTKRemoveDuplicatePolys(Node, BVTK_Node):

    bl_idname = 'VTKRemoveDuplicatePolysType'
    bl_label  = 'vtkRemoveDuplicatePolys'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKRemoveDuplicatePolys )        
TYPENAMES.append('VTKRemoveDuplicatePolysType' )

#--------------------------------------------------------------
class VTKRemoveGhosts(Node, BVTK_Node):

    bl_idname = 'VTKRemoveGhostsType'
    bl_label  = 'vtkRemoveGhosts'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKRemoveGhosts )        
TYPENAMES.append('VTKRemoveGhostsType' )

#--------------------------------------------------------------
class VTKRemovePolyData(Node, BVTK_Node):

    bl_idname = 'VTKRemovePolyDataType'
    bl_label  = 'vtkRemovePolyData'
    
    m_ExactMatch: bpy.props.BoolProperty(name='ExactMatch', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ExactMatch','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], ['CellIds', 'PointIds'], []) 
    
add_class( VTKRemovePolyData )        
TYPENAMES.append('VTKRemovePolyDataType' )

#--------------------------------------------------------------
class VTKRemoveUnusedPoints(Node, BVTK_Node):

    bl_idname = 'VTKRemoveUnusedPointsType'
    bl_label  = 'vtkRemoveUnusedPoints'
    
    m_GenerateOriginalPointIds: bpy.props.BoolProperty(name='GenerateOriginalPointIds', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_OriginalPointIdsArrayName: bpy.props.StringProperty(name='OriginalPointIdsArrayName', default="vtkOriginalPointIds", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=3, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_GenerateOriginalPointIds','m_ObjectName','m_OriginalPointIdsArrayName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKRemoveUnusedPoints )        
TYPENAMES.append('VTKRemoveUnusedPointsType' )

#--------------------------------------------------------------
class VTKResampleToImage(Node, BVTK_Node):

    bl_idname = 'VTKResampleToImageType'
    bl_label  = 'vtkResampleToImage'
    
    m_UseInputBounds: bpy.props.BoolProperty(name='UseInputBounds', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_SamplingDimensions: bpy.props.IntVectorProperty(name='SamplingDimensions', default=[10, 10, 10], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=3, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_UseInputBounds','m_ObjectName','m_SamplingDimensions',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKResampleToImage )        
TYPENAMES.append('VTKResampleToImageType' )

#--------------------------------------------------------------
class VTKReverseSense(Node, BVTK_Node):

    bl_idname = 'VTKReverseSenseType'
    bl_label  = 'vtkReverseSense'
    
    m_ReverseCells: bpy.props.BoolProperty(name='ReverseCells', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ReverseNormals: bpy.props.BoolProperty(name='ReverseNormals', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=3, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ReverseCells','m_ReverseNormals','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKReverseSense )        
TYPENAMES.append('VTKReverseSenseType' )

#--------------------------------------------------------------
class VTKRibbonFilter(Node, BVTK_Node):

    bl_idname = 'VTKRibbonFilterType'
    bl_label  = 'vtkRibbonFilter'
    e_GenerateTCoords_items=[ (x,x,x) for x in ['Off', 'NormalizedLength', 'UseLength', 'UseScalars']]
    
    m_UseDefaultNormal: bpy.props.BoolProperty(name='UseDefaultNormal', default=True, update=BVTK_Node.outdate_vtk_status)
    m_VaryWidth: bpy.props.BoolProperty(name='VaryWidth', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_Angle: bpy.props.FloatProperty(name='Angle', default=0.0, update=BVTK_Node.outdate_vtk_status)
    m_TextureLength: bpy.props.FloatProperty(name='TextureLength', default=1.0, update=BVTK_Node.outdate_vtk_status)
    m_Width: bpy.props.FloatProperty(name='Width', default=0.5, update=BVTK_Node.outdate_vtk_status)
    m_WidthFactor: bpy.props.FloatProperty(name='WidthFactor', default=2.0, update=BVTK_Node.outdate_vtk_status)
    e_GenerateTCoords: bpy.props.EnumProperty(name='GenerateTCoords', default="Off", items=e_GenerateTCoords_items, update=BVTK_Node.outdate_vtk_status)
    m_DefaultNormal: bpy.props.FloatVectorProperty(name='DefaultNormal', default=[0.0, 0.0, 1.0], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=9, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_UseDefaultNormal','m_VaryWidth','m_ObjectName','m_Angle','m_TextureLength','m_Width','m_WidthFactor','e_GenerateTCoords','m_DefaultNormal',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKRibbonFilter )        
TYPENAMES.append('VTKRibbonFilterType' )

#--------------------------------------------------------------
class VTKRotationFilter(Node, BVTK_Node):

    bl_idname = 'VTKRotationFilterType'
    bl_label  = 'vtkRotationFilter'
    e_Axis_items=[ (x,x,x) for x in ['X', 'Y', 'Z']]
    
    m_CopyInput: bpy.props.BoolProperty(name='CopyInput', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_NumberOfCopies: bpy.props.IntProperty(name='NumberOfCopies', default=0, update=BVTK_Node.outdate_vtk_status)
    m_Angle: bpy.props.FloatProperty(name='Angle', default=0.0, update=BVTK_Node.outdate_vtk_status)
    e_Axis: bpy.props.EnumProperty(name='Axis', default="Z", items=e_Axis_items, update=BVTK_Node.outdate_vtk_status)
    m_Center: bpy.props.FloatVectorProperty(name='Center', default=[0.0, 0.0, 0.0], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=6, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_CopyInput','m_ObjectName','m_NumberOfCopies','m_Angle','e_Axis','m_Center',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKRotationFilter )        
TYPENAMES.append('VTKRotationFilterType' )

#--------------------------------------------------------------
class VTKRotationalExtrusionFilter(Node, BVTK_Node):

    bl_idname = 'VTKRotationalExtrusionFilterType'
    bl_label  = 'vtkRotationalExtrusionFilter'
    
    m_Capping: bpy.props.BoolProperty(name='Capping', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_Resolution: bpy.props.IntProperty(name='Resolution', default=12, update=BVTK_Node.outdate_vtk_status)
    m_Angle: bpy.props.FloatProperty(name='Angle', default=360.0, update=BVTK_Node.outdate_vtk_status)
    m_DeltaRadius: bpy.props.FloatProperty(name='DeltaRadius', default=0.0, update=BVTK_Node.outdate_vtk_status)
    m_Translation: bpy.props.FloatProperty(name='Translation', default=0.0, update=BVTK_Node.outdate_vtk_status)
    m_RotationAxis: bpy.props.FloatVectorProperty(name='RotationAxis', default=[0.0, 0.0, 1.0], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=7, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_Capping','m_ObjectName','m_Resolution','m_Angle','m_DeltaRadius','m_Translation','m_RotationAxis',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKRotationalExtrusionFilter )        
TYPENAMES.append('VTKRotationalExtrusionFilterType' )

#--------------------------------------------------------------
class VTKRuledSurfaceFilter(Node, BVTK_Node):

    bl_idname = 'VTKRuledSurfaceFilterType'
    bl_label  = 'vtkRuledSurfaceFilter'
    e_RuledMode_items=[ (x,x,x) for x in ['Resample', 'PointWalk']]
    
    m_CloseSurface: bpy.props.BoolProperty(name='CloseSurface', default=True, update=BVTK_Node.outdate_vtk_status)
    m_OrientLoops: bpy.props.BoolProperty(name='OrientLoops', default=True, update=BVTK_Node.outdate_vtk_status)
    m_PassLines: bpy.props.BoolProperty(name='PassLines', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_Offset: bpy.props.IntProperty(name='Offset', default=0, update=BVTK_Node.outdate_vtk_status)
    m_OnRatio: bpy.props.IntProperty(name='OnRatio', default=1, update=BVTK_Node.outdate_vtk_status)
    m_DistanceFactor: bpy.props.FloatProperty(name='DistanceFactor', default=3.0, update=BVTK_Node.outdate_vtk_status)
    e_RuledMode: bpy.props.EnumProperty(name='RuledMode', default="Resample", items=e_RuledMode_items, update=BVTK_Node.outdate_vtk_status)
    m_Resolution: bpy.props.IntVectorProperty(name='Resolution', default=[1, 1], size=2, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=9, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_CloseSurface','m_OrientLoops','m_PassLines','m_ObjectName','m_Offset','m_OnRatio','m_DistanceFactor','e_RuledMode','m_Resolution',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKRuledSurfaceFilter )        
TYPENAMES.append('VTKRuledSurfaceFilterType' )

#--------------------------------------------------------------
class VTKSMPContourGrid(Node, BVTK_Node):

    bl_idname = 'VTKSMPContourGridType'
    bl_label  = 'vtkSMPContourGrid'
    
    m_ComputeNormals: bpy.props.BoolProperty(name='ComputeNormals', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ComputeScalars: bpy.props.BoolProperty(name='ComputeScalars', default=True, update=BVTK_Node.outdate_vtk_status)
    m_GenerateTriangles: bpy.props.BoolProperty(name='GenerateTriangles', default=True, update=BVTK_Node.outdate_vtk_status)
    m_MergePieces: bpy.props.BoolProperty(name='MergePieces', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_NumberOfContours: bpy.props.IntProperty(name='NumberOfContours', default=1, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=6, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ComputeNormals','m_ComputeScalars','m_GenerateTriangles','m_MergePieces','m_ObjectName','m_NumberOfContours',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKSMPContourGrid )        
TYPENAMES.append('VTKSMPContourGridType' )

#--------------------------------------------------------------
class VTKSampleImplicitFunctionFilter(Node, BVTK_Node):

    bl_idname = 'VTKSampleImplicitFunctionFilterType'
    bl_label  = 'vtkSampleImplicitFunctionFilter'
    
    m_ComputeGradients: bpy.props.BoolProperty(name='ComputeGradients', default=True, update=BVTK_Node.outdate_vtk_status)
    m_GradientArrayName: bpy.props.StringProperty(name='GradientArrayName', default="Implicit gradients", update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_ScalarArrayName: bpy.props.StringProperty(name='ScalarArrayName', default="Implicit scalars", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=4, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ComputeGradients','m_GradientArrayName','m_ObjectName','m_ScalarArrayName',]
    def m_connections( self ):
        return (['input'], ['output'], ['ImplicitFunction'], []) 
    
add_class( VTKSampleImplicitFunctionFilter )        
TYPENAMES.append('VTKSampleImplicitFunctionFilterType' )

#--------------------------------------------------------------
class VTKSelectionAlgorithm(Node, BVTK_Node):

    bl_idname = 'VTKSelectionAlgorithmType'
    bl_label  = 'vtkSelectionAlgorithm'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKSelectionAlgorithm )        
TYPENAMES.append('VTKSelectionAlgorithmType' )

#--------------------------------------------------------------
class VTKShepardMethod(Node, BVTK_Node):

    bl_idname = 'VTKShepardMethodType'
    bl_label  = 'vtkShepardMethod'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_MaximumDistance: bpy.props.FloatProperty(name='MaximumDistance', default=0.25, update=BVTK_Node.outdate_vtk_status)
    m_NullValue: bpy.props.FloatProperty(name='NullValue', default=0.0, update=BVTK_Node.outdate_vtk_status)
    m_PowerParameter: bpy.props.FloatProperty(name='PowerParameter', default=2.0, update=BVTK_Node.outdate_vtk_status)
    m_SampleDimensions: bpy.props.IntVectorProperty(name='SampleDimensions', default=[50, 50, 50], size=3, update=BVTK_Node.outdate_vtk_status)
    m_ModelBounds: bpy.props.FloatVectorProperty(name='ModelBounds', default=[0.0, 0.0, 0.0, 0.0, 0.0, 0.0], size=6, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=6, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_MaximumDistance','m_NullValue','m_PowerParameter','m_SampleDimensions','m_ModelBounds',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKShepardMethod )        
TYPENAMES.append('VTKShepardMethodType' )

#--------------------------------------------------------------
class VTKShrinkFilter(Node, BVTK_Node):

    bl_idname = 'VTKShrinkFilterType'
    bl_label  = 'vtkShrinkFilter'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_ShrinkFactor: bpy.props.FloatProperty(name='ShrinkFactor', default=0.5, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_ShrinkFactor',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKShrinkFilter )        
TYPENAMES.append('VTKShrinkFilterType' )

#--------------------------------------------------------------
class VTKShrinkPolyData(Node, BVTK_Node):

    bl_idname = 'VTKShrinkPolyDataType'
    bl_label  = 'vtkShrinkPolyData'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_ShrinkFactor: bpy.props.FloatProperty(name='ShrinkFactor', default=0.5, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_ShrinkFactor',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKShrinkPolyData )        
TYPENAMES.append('VTKShrinkPolyDataType' )

#--------------------------------------------------------------
class VTKSignedDistance(Node, BVTK_Node):

    bl_idname = 'VTKSignedDistanceType'
    bl_label  = 'vtkSignedDistance'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_Radius: bpy.props.FloatProperty(name='Radius', default=0.1, update=BVTK_Node.outdate_vtk_status)
    m_Dimensions: bpy.props.IntVectorProperty(name='Dimensions', default=[256, 256, 256], size=3, update=BVTK_Node.outdate_vtk_status)
    m_Bounds: bpy.props.FloatVectorProperty(name='Bounds', default=[0.0, 0.0, 0.0, 0.0, 0.0, 0.0], size=6, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=4, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_Radius','m_Dimensions','m_Bounds',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKSignedDistance )        
TYPENAMES.append('VTKSignedDistanceType' )

#--------------------------------------------------------------
class VTKSimpleBondPerceiver(Node, BVTK_Node):

    bl_idname = 'VTKSimpleBondPerceiverType'
    bl_label  = 'vtkSimpleBondPerceiver'
    
    m_IsToleranceAbsolute: bpy.props.BoolProperty(name='IsToleranceAbsolute', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_Tolerance: bpy.props.FloatProperty(name='Tolerance', default=0.44999998807907104, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=3, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_IsToleranceAbsolute','m_ObjectName','m_Tolerance',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKSimpleBondPerceiver )        
TYPENAMES.append('VTKSimpleBondPerceiverType' )

#--------------------------------------------------------------
class VTKSimpleElevationFilter(Node, BVTK_Node):

    bl_idname = 'VTKSimpleElevationFilterType'
    bl_label  = 'vtkSimpleElevationFilter'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_Vector: bpy.props.FloatVectorProperty(name='Vector', default=[0.0, 0.0, 1.0], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_Vector',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKSimpleElevationFilter )        
TYPENAMES.append('VTKSimpleElevationFilterType' )

#--------------------------------------------------------------
class VTKSimpleImageFilterExample(Node, BVTK_Node):

    bl_idname = 'VTKSimpleImageFilterExampleType'
    bl_label  = 'vtkSimpleImageFilterExample'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKSimpleImageFilterExample )        
TYPENAMES.append('VTKSimpleImageFilterExampleType' )

#--------------------------------------------------------------
class VTKSpatialRepresentationFilter(Node, BVTK_Node):

    bl_idname = 'VTKSpatialRepresentationFilterType'
    bl_label  = 'vtkSpatialRepresentationFilter'
    
    m_GenerateLeaves: bpy.props.BoolProperty(name='GenerateLeaves', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_GenerateLeaves','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], ['SpatialRepresentation'], []) 
    
add_class( VTKSpatialRepresentationFilter )        
TYPENAMES.append('VTKSpatialRepresentationFilterType' )

#--------------------------------------------------------------
class VTKSphereTreeFilter(Node, BVTK_Node):

    bl_idname = 'VTKSphereTreeFilterType'
    bl_label  = 'vtkSphereTreeFilter'
    e_ExtractionMode_items=[ (x,x,x) for x in ['Levels', 'Point', 'Line', 'Plane']]
    
    m_TreeHierarchy: bpy.props.BoolProperty(name='TreeHierarchy', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_Level: bpy.props.IntProperty(name='Level', default=-1, update=BVTK_Node.outdate_vtk_status)
    e_ExtractionMode: bpy.props.EnumProperty(name='ExtractionMode', default="Levels", items=e_ExtractionMode_items, update=BVTK_Node.outdate_vtk_status)
    m_Normal: bpy.props.FloatVectorProperty(name='Normal', default=[0.0, 0.0, 1.0], size=3, update=BVTK_Node.outdate_vtk_status)
    m_Point: bpy.props.FloatVectorProperty(name='Point', default=[0.0, 0.0, 0.0], size=3, update=BVTK_Node.outdate_vtk_status)
    m_Ray: bpy.props.FloatVectorProperty(name='Ray', default=[1.0, 0.0, 0.0], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=7, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_TreeHierarchy','m_ObjectName','m_Level','e_ExtractionMode','m_Normal','m_Point','m_Ray',]
    def m_connections( self ):
        return (['input'], ['output'], ['SphereTree'], []) 
    
add_class( VTKSphereTreeFilter )        
TYPENAMES.append('VTKSphereTreeFilterType' )

#--------------------------------------------------------------
class VTKSphericalHarmonics(Node, BVTK_Node):

    bl_idname = 'VTKSphericalHarmonicsType'
    bl_label  = 'vtkSphericalHarmonics'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKSphericalHarmonics )        
TYPENAMES.append('VTKSphericalHarmonicsType' )

#--------------------------------------------------------------
class VTKSplineFilter(Node, BVTK_Node):

    bl_idname = 'VTKSplineFilterType'
    bl_label  = 'vtkSplineFilter'
    e_GenerateTCoords_items=[ (x,x,x) for x in ['Off', 'NormalizedLength', 'UseLength', 'UseScalars']]
    e_Subdivide_items=[ (x,x,x) for x in ['Specified', 'Length']]
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_MaximumNumberOfSubdivisions: bpy.props.IntProperty(name='MaximumNumberOfSubdivisions', default=1000000000, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfSubdivisions: bpy.props.IntProperty(name='NumberOfSubdivisions', default=100, update=BVTK_Node.outdate_vtk_status)
    m_Length: bpy.props.FloatProperty(name='Length', default=0.1, update=BVTK_Node.outdate_vtk_status)
    m_TextureLength: bpy.props.FloatProperty(name='TextureLength', default=1.0, update=BVTK_Node.outdate_vtk_status)
    e_GenerateTCoords: bpy.props.EnumProperty(name='GenerateTCoords', default="NormalizedLength", items=e_GenerateTCoords_items, update=BVTK_Node.outdate_vtk_status)
    e_Subdivide: bpy.props.EnumProperty(name='Subdivide', default="Specified", items=e_Subdivide_items, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=7, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_MaximumNumberOfSubdivisions','m_NumberOfSubdivisions','m_Length','m_TextureLength','e_GenerateTCoords','e_Subdivide',]
    def m_connections( self ):
        return (['input'], ['output'], ['Spline'], []) 
    
add_class( VTKSplineFilter )        
TYPENAMES.append('VTKSplineFilterType' )

#--------------------------------------------------------------
class VTKSplitByCellScalarFilter(Node, BVTK_Node):

    bl_idname = 'VTKSplitByCellScalarFilterType'
    bl_label  = 'vtkSplitByCellScalarFilter'
    
    m_PassAllPoints: bpy.props.BoolProperty(name='PassAllPoints', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_PassAllPoints','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKSplitByCellScalarFilter )        
TYPENAMES.append('VTKSplitByCellScalarFilterType' )

#--------------------------------------------------------------
class VTKSplitColumnComponents(Node, BVTK_Node):

    bl_idname = 'VTKSplitColumnComponentsType'
    bl_label  = 'vtkSplitColumnComponents'
    e_NamingMode_items=[ (x,x,x) for x in ['NumberWithParens', 'NamesWithParens', 'NumberWithUnderscores', 'NamesWithUnderscores']]
    
    m_CalculateMagnitudes: bpy.props.BoolProperty(name='CalculateMagnitudes', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    e_NamingMode: bpy.props.EnumProperty(name='NamingMode', default="NumberWithParens", items=e_NamingMode_items, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=3, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_CalculateMagnitudes','m_ObjectName','e_NamingMode',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKSplitColumnComponents )        
TYPENAMES.append('VTKSplitColumnComponentsType' )

#--------------------------------------------------------------
class VTKSplitField(Node, BVTK_Node):

    bl_idname = 'VTKSplitFieldType'
    bl_label  = 'vtkSplitField'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKSplitField )        
TYPENAMES.append('VTKSplitFieldType' )

#--------------------------------------------------------------
class VTKStaticCleanPolyData(Node, BVTK_Node):

    bl_idname = 'VTKStaticCleanPolyDataType'
    bl_label  = 'vtkStaticCleanPolyData'
    
    m_AveragePointData: bpy.props.BoolProperty(name='AveragePointData', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ConvertLinesToPoints: bpy.props.BoolProperty(name='ConvertLinesToPoints', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ConvertPolysToLines: bpy.props.BoolProperty(name='ConvertPolysToLines', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ConvertStripsToPolys: bpy.props.BoolProperty(name='ConvertStripsToPolys', default=False, update=BVTK_Node.outdate_vtk_status)
    m_PieceInvariant: bpy.props.BoolProperty(name='PieceInvariant', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ProduceMergeMap: bpy.props.BoolProperty(name='ProduceMergeMap', default=False, update=BVTK_Node.outdate_vtk_status)
    m_RemoveUnusedPoints: bpy.props.BoolProperty(name='RemoveUnusedPoints', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ToleranceIsAbsolute: bpy.props.BoolProperty(name='ToleranceIsAbsolute', default=False, update=BVTK_Node.outdate_vtk_status)
    m_MergingArray: bpy.props.StringProperty(name='MergingArray', default="", update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_AbsoluteTolerance: bpy.props.FloatProperty(name='AbsoluteTolerance', default=0.0, update=BVTK_Node.outdate_vtk_status)
    m_Tolerance: bpy.props.FloatProperty(name='Tolerance', default=0.0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=12, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_AveragePointData','m_ConvertLinesToPoints','m_ConvertPolysToLines','m_ConvertStripsToPolys','m_PieceInvariant','m_ProduceMergeMap','m_RemoveUnusedPoints','m_ToleranceIsAbsolute','m_MergingArray','m_ObjectName','m_AbsoluteTolerance','m_Tolerance',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKStaticCleanPolyData )        
TYPENAMES.append('VTKStaticCleanPolyDataType' )

#--------------------------------------------------------------
class VTKStaticCleanUnstructuredGrid(Node, BVTK_Node):

    bl_idname = 'VTKStaticCleanUnstructuredGridType'
    bl_label  = 'vtkStaticCleanUnstructuredGrid'
    
    m_AveragePointData: bpy.props.BoolProperty(name='AveragePointData', default=False, update=BVTK_Node.outdate_vtk_status)
    m_PieceInvariant: bpy.props.BoolProperty(name='PieceInvariant', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ProduceMergeMap: bpy.props.BoolProperty(name='ProduceMergeMap', default=False, update=BVTK_Node.outdate_vtk_status)
    m_RemoveUnusedPoints: bpy.props.BoolProperty(name='RemoveUnusedPoints', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ToleranceIsAbsolute: bpy.props.BoolProperty(name='ToleranceIsAbsolute', default=False, update=BVTK_Node.outdate_vtk_status)
    m_MergingArray: bpy.props.StringProperty(name='MergingArray', default="", update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_AbsoluteTolerance: bpy.props.FloatProperty(name='AbsoluteTolerance', default=0.0, update=BVTK_Node.outdate_vtk_status)
    m_Tolerance: bpy.props.FloatProperty(name='Tolerance', default=0.0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=9, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_AveragePointData','m_PieceInvariant','m_ProduceMergeMap','m_RemoveUnusedPoints','m_ToleranceIsAbsolute','m_MergingArray','m_ObjectName','m_AbsoluteTolerance','m_Tolerance',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKStaticCleanUnstructuredGrid )        
TYPENAMES.append('VTKStaticCleanUnstructuredGridType' )

#--------------------------------------------------------------
class VTKStrahlerMetric(Node, BVTK_Node):

    bl_idname = 'VTKStrahlerMetricType'
    bl_label  = 'vtkStrahlerMetric'
    
    m_Normalize: bpy.props.BoolProperty(name='Normalize', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_Normalize','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKStrahlerMetric )        
TYPENAMES.append('VTKStrahlerMetricType' )

#--------------------------------------------------------------
class VTKStripper(Node, BVTK_Node):

    bl_idname = 'VTKStripperType'
    bl_label  = 'vtkStripper'
    
    m_JoinContiguousSegments: bpy.props.BoolProperty(name='JoinContiguousSegments', default=True, update=BVTK_Node.outdate_vtk_status)
    m_PassCellDataAsFieldData: bpy.props.BoolProperty(name='PassCellDataAsFieldData', default=True, update=BVTK_Node.outdate_vtk_status)
    m_PassThroughCellIds: bpy.props.BoolProperty(name='PassThroughCellIds', default=True, update=BVTK_Node.outdate_vtk_status)
    m_PassThroughPointIds: bpy.props.BoolProperty(name='PassThroughPointIds', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_MaximumLength: bpy.props.IntProperty(name='MaximumLength', default=1000, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=6, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_JoinContiguousSegments','m_PassCellDataAsFieldData','m_PassThroughCellIds','m_PassThroughPointIds','m_ObjectName','m_MaximumLength',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKStripper )        
TYPENAMES.append('VTKStripperType' )

#--------------------------------------------------------------
class VTKStructuredGridAlgorithm(Node, BVTK_Node):

    bl_idname = 'VTKStructuredGridAlgorithmType'
    bl_label  = 'vtkStructuredGridAlgorithm'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKStructuredGridAlgorithm )        
TYPENAMES.append('VTKStructuredGridAlgorithmType' )

#--------------------------------------------------------------
class VTKStructuredGridAppend(Node, BVTK_Node):

    bl_idname = 'VTKStructuredGridAppendType'
    bl_label  = 'vtkStructuredGridAppend'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKStructuredGridAppend )        
TYPENAMES.append('VTKStructuredGridAppendType' )

#--------------------------------------------------------------
class VTKStructuredGridClip(Node, BVTK_Node):

    bl_idname = 'VTKStructuredGridClipType'
    bl_label  = 'vtkStructuredGridClip'
    
    m_ClipData: bpy.props.BoolProperty(name='ClipData', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ClipData','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKStructuredGridClip )        
TYPENAMES.append('VTKStructuredGridClipType' )

#--------------------------------------------------------------
class VTKStructuredGridGeometryFilter(Node, BVTK_Node):

    bl_idname = 'VTKStructuredGridGeometryFilterType'
    bl_label  = 'vtkStructuredGridGeometryFilter'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_Extent: bpy.props.IntVectorProperty(name='Extent', default=[0, 1000000000, 0, 1000000000, 0, 1000000000], size=6, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_Extent',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKStructuredGridGeometryFilter )        
TYPENAMES.append('VTKStructuredGridGeometryFilterType' )

#--------------------------------------------------------------
class VTKStructuredGridGhostDataGenerator(Node, BVTK_Node):

    bl_idname = 'VTKStructuredGridGhostDataGeneratorType'
    bl_label  = 'vtkStructuredGridGhostDataGenerator'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_NumberOfGhostLayers: bpy.props.IntProperty(name='NumberOfGhostLayers', default=0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_NumberOfGhostLayers',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKStructuredGridGhostDataGenerator )        
TYPENAMES.append('VTKStructuredGridGhostDataGeneratorType' )

#--------------------------------------------------------------
class VTKStructuredGridOutlineFilter(Node, BVTK_Node):

    bl_idname = 'VTKStructuredGridOutlineFilterType'
    bl_label  = 'vtkStructuredGridOutlineFilter'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKStructuredGridOutlineFilter )        
TYPENAMES.append('VTKStructuredGridOutlineFilterType' )

#--------------------------------------------------------------
class VTKStructuredGridPartitioner(Node, BVTK_Node):

    bl_idname = 'VTKStructuredGridPartitionerType'
    bl_label  = 'vtkStructuredGridPartitioner'
    
    m_DuplicateNodes: bpy.props.BoolProperty(name='DuplicateNodes', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_NumberOfGhostLayers: bpy.props.IntProperty(name='NumberOfGhostLayers', default=0, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfPartitions: bpy.props.IntProperty(name='NumberOfPartitions', default=2, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=4, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_DuplicateNodes','m_ObjectName','m_NumberOfGhostLayers','m_NumberOfPartitions',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKStructuredGridPartitioner )        
TYPENAMES.append('VTKStructuredGridPartitionerType' )

#--------------------------------------------------------------
class VTKSubdivideTetra(Node, BVTK_Node):

    bl_idname = 'VTKSubdivideTetraType'
    bl_label  = 'vtkSubdivideTetra'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKSubdivideTetra )        
TYPENAMES.append('VTKSubdivideTetraType' )

#--------------------------------------------------------------
class VTKSurfaceNets2D(Node, BVTK_Node):

    bl_idname = 'VTKSurfaceNets2DType'
    bl_label  = 'vtkSurfaceNets2D'
    
    m_ComputeScalars: bpy.props.BoolProperty(name='ComputeScalars', default=True, update=BVTK_Node.outdate_vtk_status)
    m_DataCaching: bpy.props.BoolProperty(name='DataCaching', default=True, update=BVTK_Node.outdate_vtk_status)
    m_Smoothing: bpy.props.BoolProperty(name='Smoothing', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_ArrayComponent: bpy.props.IntProperty(name='ArrayComponent', default=0, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfContours: bpy.props.IntProperty(name='NumberOfContours', default=1, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfLabels: bpy.props.IntProperty(name='NumberOfLabels', default=1, update=BVTK_Node.outdate_vtk_status)
    m_BackgroundLabel: bpy.props.FloatProperty(name='BackgroundLabel', default=0.0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=8, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ComputeScalars','m_DataCaching','m_Smoothing','m_ObjectName','m_ArrayComponent','m_NumberOfContours','m_NumberOfLabels','m_BackgroundLabel',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKSurfaceNets2D )        
TYPENAMES.append('VTKSurfaceNets2DType' )

#--------------------------------------------------------------
class VTKSurfaceReconstructionFilter(Node, BVTK_Node):

    bl_idname = 'VTKSurfaceReconstructionFilterType'
    bl_label  = 'vtkSurfaceReconstructionFilter'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_NeighborhoodSize: bpy.props.IntProperty(name='NeighborhoodSize', default=20, update=BVTK_Node.outdate_vtk_status)
    m_SampleSpacing: bpy.props.FloatProperty(name='SampleSpacing', default=-1.0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=3, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_NeighborhoodSize','m_SampleSpacing',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKSurfaceReconstructionFilter )        
TYPENAMES.append('VTKSurfaceReconstructionFilterType' )

#--------------------------------------------------------------
class VTKSynchronizedTemplates2D(Node, BVTK_Node):

    bl_idname = 'VTKSynchronizedTemplates2DType'
    bl_label  = 'vtkSynchronizedTemplates2D'
    
    m_ComputeScalars: bpy.props.BoolProperty(name='ComputeScalars', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_ArrayComponent: bpy.props.IntProperty(name='ArrayComponent', default=0, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfContours: bpy.props.IntProperty(name='NumberOfContours', default=1, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=4, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ComputeScalars','m_ObjectName','m_ArrayComponent','m_NumberOfContours',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKSynchronizedTemplates2D )        
TYPENAMES.append('VTKSynchronizedTemplates2DType' )

#--------------------------------------------------------------
class VTKTableAlgorithm(Node, BVTK_Node):

    bl_idname = 'VTKTableAlgorithmType'
    bl_label  = 'vtkTableAlgorithm'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKTableAlgorithm )        
TYPENAMES.append('VTKTableAlgorithmType' )

#--------------------------------------------------------------
class VTKTableFFT(Node, BVTK_Node):

    bl_idname = 'VTKTableFFTType'
    bl_label  = 'vtkTableFFT'
    
    m_AverageFft: bpy.props.BoolProperty(name='AverageFft', default=False, update=BVTK_Node.outdate_vtk_status)
    m_CreateFrequencyColumn: bpy.props.BoolProperty(name='CreateFrequencyColumn', default=False, update=BVTK_Node.outdate_vtk_status)
    m_Normalize: bpy.props.BoolProperty(name='Normalize', default=False, update=BVTK_Node.outdate_vtk_status)
    m_OptimizeForRealInput: bpy.props.BoolProperty(name='OptimizeForRealInput', default=False, update=BVTK_Node.outdate_vtk_status)
    m_PrefixOutputArrays: bpy.props.BoolProperty(name='PrefixOutputArrays', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_BlockSize: bpy.props.IntProperty(name='BlockSize', default=1024, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfBlock: bpy.props.IntProperty(name='NumberOfBlock', default=2, update=BVTK_Node.outdate_vtk_status)
    m_WindowingFunction: bpy.props.IntProperty(name='WindowingFunction', default=4, update=BVTK_Node.outdate_vtk_status)
    m_DefaultSampleRate: bpy.props.FloatProperty(name='DefaultSampleRate', default=10000.0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=10, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_AverageFft','m_CreateFrequencyColumn','m_Normalize','m_OptimizeForRealInput','m_PrefixOutputArrays','m_ObjectName','m_BlockSize','m_NumberOfBlock','m_WindowingFunction','m_DefaultSampleRate',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKTableFFT )        
TYPENAMES.append('VTKTableFFTType' )

#--------------------------------------------------------------
class VTKTableToPolyData(Node, BVTK_Node):

    bl_idname = 'VTKTableToPolyDataType'
    bl_label  = 'vtkTableToPolyData'
    
    m_Create2DPoints: bpy.props.BoolProperty(name='Create2DPoints', default=False, update=BVTK_Node.outdate_vtk_status)
    m_PreserveCoordinateColumnsAsDataArrays: bpy.props.BoolProperty(name='PreserveCoordinateColumnsAsDataArrays', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_XColumn: bpy.props.StringProperty(name='XColumn', default="", update=BVTK_Node.outdate_vtk_status)
    m_YColumn: bpy.props.StringProperty(name='YColumn', default="", update=BVTK_Node.outdate_vtk_status)
    m_ZColumn: bpy.props.StringProperty(name='ZColumn', default="", update=BVTK_Node.outdate_vtk_status)
    m_XColumnIndex: bpy.props.IntProperty(name='XColumnIndex', default=-1, update=BVTK_Node.outdate_vtk_status)
    m_XComponent: bpy.props.IntProperty(name='XComponent', default=0, update=BVTK_Node.outdate_vtk_status)
    m_YColumnIndex: bpy.props.IntProperty(name='YColumnIndex', default=-1, update=BVTK_Node.outdate_vtk_status)
    m_YComponent: bpy.props.IntProperty(name='YComponent', default=0, update=BVTK_Node.outdate_vtk_status)
    m_ZColumnIndex: bpy.props.IntProperty(name='ZColumnIndex', default=-1, update=BVTK_Node.outdate_vtk_status)
    m_ZComponent: bpy.props.IntProperty(name='ZComponent', default=0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=12, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_Create2DPoints','m_PreserveCoordinateColumnsAsDataArrays','m_ObjectName','m_XColumn','m_YColumn','m_ZColumn','m_XColumnIndex','m_XComponent','m_YColumnIndex','m_YComponent','m_ZColumnIndex','m_ZComponent',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKTableToPolyData )        
TYPENAMES.append('VTKTableToPolyDataType' )

#--------------------------------------------------------------
class VTKTableToStructuredGrid(Node, BVTK_Node):

    bl_idname = 'VTKTableToStructuredGridType'
    bl_label  = 'vtkTableToStructuredGrid'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_XColumn: bpy.props.StringProperty(name='XColumn', default="", update=BVTK_Node.outdate_vtk_status)
    m_YColumn: bpy.props.StringProperty(name='YColumn', default="", update=BVTK_Node.outdate_vtk_status)
    m_ZColumn: bpy.props.StringProperty(name='ZColumn', default="", update=BVTK_Node.outdate_vtk_status)
    m_XComponent: bpy.props.IntProperty(name='XComponent', default=0, update=BVTK_Node.outdate_vtk_status)
    m_YComponent: bpy.props.IntProperty(name='YComponent', default=0, update=BVTK_Node.outdate_vtk_status)
    m_ZComponent: bpy.props.IntProperty(name='ZComponent', default=0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=7, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_XColumn','m_YColumn','m_ZColumn','m_XComponent','m_YComponent','m_ZComponent',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKTableToStructuredGrid )        
TYPENAMES.append('VTKTableToStructuredGridType' )

#--------------------------------------------------------------
class VTKTemporalArrayOperatorFilter(Node, BVTK_Node):

    bl_idname = 'VTKTemporalArrayOperatorFilterType'
    bl_label  = 'vtkTemporalArrayOperatorFilter'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_OutputArrayNameSuffix: bpy.props.StringProperty(name='OutputArrayNameSuffix', default="", update=BVTK_Node.outdate_vtk_status)
    m_FirstTimeStepIndex: bpy.props.IntProperty(name='FirstTimeStepIndex', default=0, update=BVTK_Node.outdate_vtk_status)
    m_Operator: bpy.props.IntProperty(name='Operator', default=0, update=BVTK_Node.outdate_vtk_status)
    m_SecondTimeStepIndex: bpy.props.IntProperty(name='SecondTimeStepIndex', default=0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=5, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_OutputArrayNameSuffix','m_FirstTimeStepIndex','m_Operator','m_SecondTimeStepIndex',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKTemporalArrayOperatorFilter )        
TYPENAMES.append('VTKTemporalArrayOperatorFilterType' )

#--------------------------------------------------------------
class VTKTemporalDataSetCache(Node, BVTK_Node):

    bl_idname = 'VTKTemporalDataSetCacheType'
    bl_label  = 'vtkTemporalDataSetCache'
    
    m_CacheInMemkind: bpy.props.BoolProperty(name='CacheInMemkind', default=False, update=BVTK_Node.outdate_vtk_status)
    m_IsASource: bpy.props.BoolProperty(name='IsASource', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_CacheSize: bpy.props.IntProperty(name='CacheSize', default=10, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=4, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_CacheInMemkind','m_IsASource','m_ObjectName','m_CacheSize',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKTemporalDataSetCache )        
TYPENAMES.append('VTKTemporalDataSetCacheType' )

#--------------------------------------------------------------
class VTKTemporalInterpolator(Node, BVTK_Node):

    bl_idname = 'VTKTemporalInterpolatorType'
    bl_label  = 'vtkTemporalInterpolator'
    
    m_CacheData: bpy.props.BoolProperty(name='CacheData', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_ResampleFactor: bpy.props.IntProperty(name='ResampleFactor', default=0, update=BVTK_Node.outdate_vtk_status)
    m_DiscreteTimeStepInterval: bpy.props.FloatProperty(name='DiscreteTimeStepInterval', default=0.0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=4, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_CacheData','m_ObjectName','m_ResampleFactor','m_DiscreteTimeStepInterval',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKTemporalInterpolator )        
TYPENAMES.append('VTKTemporalInterpolatorType' )

#--------------------------------------------------------------
class VTKTemporalShiftScale(Node, BVTK_Node):

    bl_idname = 'VTKTemporalShiftScaleType'
    bl_label  = 'vtkTemporalShiftScale'
    
    m_Periodic: bpy.props.BoolProperty(name='Periodic', default=True, update=BVTK_Node.outdate_vtk_status)
    m_PeriodicEndCorrection: bpy.props.BoolProperty(name='PeriodicEndCorrection', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_MaximumNumberOfPeriods: bpy.props.FloatProperty(name='MaximumNumberOfPeriods', default=1.0, update=BVTK_Node.outdate_vtk_status)
    m_PostShift: bpy.props.FloatProperty(name='PostShift', default=0.0, update=BVTK_Node.outdate_vtk_status)
    m_PreShift: bpy.props.FloatProperty(name='PreShift', default=0.0, update=BVTK_Node.outdate_vtk_status)
    m_Scale: bpy.props.FloatProperty(name='Scale', default=1.0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=7, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_Periodic','m_PeriodicEndCorrection','m_ObjectName','m_MaximumNumberOfPeriods','m_PostShift','m_PreShift','m_Scale',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKTemporalShiftScale )        
TYPENAMES.append('VTKTemporalShiftScaleType' )

#--------------------------------------------------------------
class VTKTemporalSnapToTimeStep(Node, BVTK_Node):

    bl_idname = 'VTKTemporalSnapToTimeStepType'
    bl_label  = 'vtkTemporalSnapToTimeStep'
    e_SnapMode_items=[ (x,x,x) for x in ['Nearest', 'NextBelowOrEqual', 'NextAboveOrEqual']]
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    e_SnapMode: bpy.props.EnumProperty(name='SnapMode', default="Nearest", items=e_SnapMode_items, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','e_SnapMode',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKTemporalSnapToTimeStep )        
TYPENAMES.append('VTKTemporalSnapToTimeStepType' )

#--------------------------------------------------------------
class VTKTemporalStatistics(Node, BVTK_Node):

    bl_idname = 'VTKTemporalStatisticsType'
    bl_label  = 'vtkTemporalStatistics'
    
    m_ComputeAverage: bpy.props.BoolProperty(name='ComputeAverage', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ComputeMaximum: bpy.props.BoolProperty(name='ComputeMaximum', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ComputeMinimum: bpy.props.BoolProperty(name='ComputeMinimum', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ComputeStandardDeviation: bpy.props.BoolProperty(name='ComputeStandardDeviation', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=5, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ComputeAverage','m_ComputeMaximum','m_ComputeMinimum','m_ComputeStandardDeviation','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKTemporalStatistics )        
TYPENAMES.append('VTKTemporalStatisticsType' )

#--------------------------------------------------------------
class VTKTessellatorFilter(Node, BVTK_Node):

    bl_idname = 'VTKTessellatorFilterType'
    bl_label  = 'vtkTessellatorFilter'
    
    m_MergePoints: bpy.props.BoolProperty(name='MergePoints', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_MaximumNumberOfSubdivisions: bpy.props.IntProperty(name='MaximumNumberOfSubdivisions', default=3, update=BVTK_Node.outdate_vtk_status)
    m_OutputDimension: bpy.props.IntProperty(name='OutputDimension', default=3, update=BVTK_Node.outdate_vtk_status)
    m_ChordError: bpy.props.FloatProperty(name='ChordError', default=0.001, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=5, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_MergePoints','m_ObjectName','m_MaximumNumberOfSubdivisions','m_OutputDimension','m_ChordError',]
    def m_connections( self ):
        return (['input'], ['output'], ['Subdivider', 'Tessellator'], []) 
    
add_class( VTKTessellatorFilter )        
TYPENAMES.append('VTKTessellatorFilterType' )

#--------------------------------------------------------------
class VTKTextureMapToCylinder(Node, BVTK_Node):

    bl_idname = 'VTKTextureMapToCylinderType'
    bl_label  = 'vtkTextureMapToCylinder'
    
    m_AutomaticCylinderGeneration: bpy.props.BoolProperty(name='AutomaticCylinderGeneration', default=True, update=BVTK_Node.outdate_vtk_status)
    m_PreventSeam: bpy.props.BoolProperty(name='PreventSeam', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_Point1: bpy.props.FloatVectorProperty(name='Point1', default=[0.0, 0.0, -0.5], size=3, update=BVTK_Node.outdate_vtk_status)
    m_Point2: bpy.props.FloatVectorProperty(name='Point2', default=[0.0, 0.0, 0.5], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=5, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_AutomaticCylinderGeneration','m_PreventSeam','m_ObjectName','m_Point1','m_Point2',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKTextureMapToCylinder )        
TYPENAMES.append('VTKTextureMapToCylinderType' )

#--------------------------------------------------------------
class VTKTextureMapToPlane(Node, BVTK_Node):

    bl_idname = 'VTKTextureMapToPlaneType'
    bl_label  = 'vtkTextureMapToPlane'
    
    m_AutomaticPlaneGeneration: bpy.props.BoolProperty(name='AutomaticPlaneGeneration', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_Normal: bpy.props.FloatVectorProperty(name='Normal', default=[0.0, 0.0, 1.0], size=3, update=BVTK_Node.outdate_vtk_status)
    m_Origin: bpy.props.FloatVectorProperty(name='Origin', default=[0.0, 0.0, 0.0], size=3, update=BVTK_Node.outdate_vtk_status)
    m_Point1: bpy.props.FloatVectorProperty(name='Point1', default=[0.0, 0.0, 0.0], size=3, update=BVTK_Node.outdate_vtk_status)
    m_Point2: bpy.props.FloatVectorProperty(name='Point2', default=[0.0, 0.0, 0.0], size=3, update=BVTK_Node.outdate_vtk_status)
    m_SRange: bpy.props.FloatVectorProperty(name='SRange', default=[0.0, 1.0], size=2, update=BVTK_Node.outdate_vtk_status)
    m_TRange: bpy.props.FloatVectorProperty(name='TRange', default=[0.0, 1.0], size=2, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=8, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_AutomaticPlaneGeneration','m_ObjectName','m_Normal','m_Origin','m_Point1','m_Point2','m_SRange','m_TRange',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKTextureMapToPlane )        
TYPENAMES.append('VTKTextureMapToPlaneType' )

#--------------------------------------------------------------
class VTKTextureMapToSphere(Node, BVTK_Node):

    bl_idname = 'VTKTextureMapToSphereType'
    bl_label  = 'vtkTextureMapToSphere'
    
    m_AutomaticSphereGeneration: bpy.props.BoolProperty(name='AutomaticSphereGeneration', default=True, update=BVTK_Node.outdate_vtk_status)
    m_PreventSeam: bpy.props.BoolProperty(name='PreventSeam', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_Center: bpy.props.FloatVectorProperty(name='Center', default=[0.0, 0.0, 0.0], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=4, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_AutomaticSphereGeneration','m_PreventSeam','m_ObjectName','m_Center',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKTextureMapToSphere )        
TYPENAMES.append('VTKTextureMapToSphereType' )

#--------------------------------------------------------------
class VTKThreshold(Node, BVTK_Node):

    bl_idname = 'VTKThresholdType'
    bl_label  = 'vtkThreshold'
    e_AttributeMode_items=[ (x,x,x) for x in ['Default', 'UsePointData', 'UseCellData']]
    e_ComponentMode_items=[ (x,x,x) for x in ['UseSelected', 'UseAll', 'UseAny']]
    e_PointsDataType_items=[ (x,x,x) for x in ['Float', 'Double']]
    
    m_AllScalars: bpy.props.BoolProperty(name='AllScalars', default=True, update=BVTK_Node.outdate_vtk_status)
    m_Invert: bpy.props.BoolProperty(name='Invert', default=False, update=BVTK_Node.outdate_vtk_status)
    m_UseContinuousCellRange: bpy.props.BoolProperty(name='UseContinuousCellRange', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_SelectedComponent: bpy.props.IntProperty(name='SelectedComponent', default=0, update=BVTK_Node.outdate_vtk_status)
    m_ThresholdFunction: bpy.props.IntProperty(name='ThresholdFunction', default=0, update=BVTK_Node.outdate_vtk_status)
    m_LowerThreshold: bpy.props.FloatProperty(name='LowerThreshold', default=-1e+30, update=BVTK_Node.outdate_vtk_status)
    m_UpperThreshold: bpy.props.FloatProperty(name='UpperThreshold', default=1e+30, update=BVTK_Node.outdate_vtk_status)
    e_AttributeMode: bpy.props.EnumProperty(name='AttributeMode', default="Default", items=e_AttributeMode_items, update=BVTK_Node.outdate_vtk_status)
    e_ComponentMode: bpy.props.EnumProperty(name='ComponentMode', default="UseSelected", items=e_ComponentMode_items, update=BVTK_Node.outdate_vtk_status)
    e_PointsDataType: bpy.props.EnumProperty(name='PointsDataType', default="Double", items=e_PointsDataType_items, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=11, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_AllScalars','m_Invert','m_UseContinuousCellRange','m_ObjectName','m_SelectedComponent','m_ThresholdFunction','m_LowerThreshold','m_UpperThreshold','e_AttributeMode','e_ComponentMode','e_PointsDataType',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKThreshold )        
TYPENAMES.append('VTKThresholdType' )

#--------------------------------------------------------------
class VTKThresholdPoints(Node, BVTK_Node):

    bl_idname = 'VTKThresholdPointsType'
    bl_label  = 'vtkThresholdPoints'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_InputArrayComponent: bpy.props.IntProperty(name='InputArrayComponent', default=0, update=BVTK_Node.outdate_vtk_status)
    m_LowerThreshold: bpy.props.FloatProperty(name='LowerThreshold', default=0.0, update=BVTK_Node.outdate_vtk_status)
    m_UpperThreshold: bpy.props.FloatProperty(name='UpperThreshold', default=0.0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=4, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_InputArrayComponent','m_LowerThreshold','m_UpperThreshold',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKThresholdPoints )        
TYPENAMES.append('VTKThresholdPointsType' )

#--------------------------------------------------------------
class VTKThresholdTextureCoords(Node, BVTK_Node):

    bl_idname = 'VTKThresholdTextureCoordsType'
    bl_label  = 'vtkThresholdTextureCoords'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_TextureDimension: bpy.props.IntProperty(name='TextureDimension', default=2, update=BVTK_Node.outdate_vtk_status)
    m_InTextureCoord: bpy.props.FloatVectorProperty(name='InTextureCoord', default=[0.75, 0.0, 0.0], size=3, update=BVTK_Node.outdate_vtk_status)
    m_OutTextureCoord: bpy.props.FloatVectorProperty(name='OutTextureCoord', default=[0.25, 0.0, 0.0], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=4, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_TextureDimension','m_InTextureCoord','m_OutTextureCoord',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKThresholdTextureCoords )        
TYPENAMES.append('VTKThresholdTextureCoordsType' )

#--------------------------------------------------------------
class VTKTransformCoordinateSystems(Node, BVTK_Node):

    bl_idname = 'VTKTransformCoordinateSystemsType'
    bl_label  = 'vtkTransformCoordinateSystems'
    e_InputCoordinateSystem_items=[ (x,x,x) for x in ['Display', 'Viewport', 'World']]
    e_OutputCoordinateSystem_items=[ (x,x,x) for x in ['Display', 'Viewport', 'World']]
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    e_InputCoordinateSystem: bpy.props.EnumProperty(name='InputCoordinateSystem', default="World", items=e_InputCoordinateSystem_items, update=BVTK_Node.outdate_vtk_status)
    e_OutputCoordinateSystem: bpy.props.EnumProperty(name='OutputCoordinateSystem', default="Display", items=e_OutputCoordinateSystem_items, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=3, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','e_InputCoordinateSystem','e_OutputCoordinateSystem',]
    def m_connections( self ):
        return (['input'], ['output'], ['Viewport'], []) 
    
add_class( VTKTransformCoordinateSystems )        
TYPENAMES.append('VTKTransformCoordinateSystemsType' )

#--------------------------------------------------------------
class VTKTransformFilter(Node, BVTK_Node):

    bl_idname = 'VTKTransformFilterType'
    bl_label  = 'vtkTransformFilter'
    
    m_TransformAllInputVectors: bpy.props.BoolProperty(name='TransformAllInputVectors', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_TransformAllInputVectors','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], ['Transform'], []) 
    
add_class( VTKTransformFilter )        
TYPENAMES.append('VTKTransformFilterType' )

#--------------------------------------------------------------
class VTKTransformPolyDataFilter(Node, BVTK_Node):

    bl_idname = 'VTKTransformPolyDataFilterType'
    bl_label  = 'vtkTransformPolyDataFilter'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], ['Transform'], []) 
    
add_class( VTKTransformPolyDataFilter )        
TYPENAMES.append('VTKTransformPolyDataFilterType' )

#--------------------------------------------------------------
class VTKTransformTextureCoords(Node, BVTK_Node):

    bl_idname = 'VTKTransformTextureCoordsType'
    bl_label  = 'vtkTransformTextureCoords'
    
    m_FlipR: bpy.props.BoolProperty(name='FlipR', default=True, update=BVTK_Node.outdate_vtk_status)
    m_FlipS: bpy.props.BoolProperty(name='FlipS', default=True, update=BVTK_Node.outdate_vtk_status)
    m_FlipT: bpy.props.BoolProperty(name='FlipT', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_Origin: bpy.props.FloatVectorProperty(name='Origin', default=[0.5, 0.5, 0.5], size=3, update=BVTK_Node.outdate_vtk_status)
    m_Position: bpy.props.FloatVectorProperty(name='Position', default=[0.0, 0.0, 0.0], size=3, update=BVTK_Node.outdate_vtk_status)
    m_Scale: bpy.props.FloatVectorProperty(name='Scale', default=[1.0, 1.0, 1.0], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=7, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_FlipR','m_FlipS','m_FlipT','m_ObjectName','m_Origin','m_Position','m_Scale',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKTransformTextureCoords )        
TYPENAMES.append('VTKTransformTextureCoordsType' )

#--------------------------------------------------------------
class VTKTransmitImageDataPiece(Node, BVTK_Node):

    bl_idname = 'VTKTransmitImageDataPieceType'
    bl_label  = 'vtkTransmitImageDataPiece'
    
    m_CreateGhostCells: bpy.props.BoolProperty(name='CreateGhostCells', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_CreateGhostCells','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKTransmitImageDataPiece )        
TYPENAMES.append('VTKTransmitImageDataPieceType' )

#--------------------------------------------------------------
class VTKTransmitPolyDataPiece(Node, BVTK_Node):

    bl_idname = 'VTKTransmitPolyDataPieceType'
    bl_label  = 'vtkTransmitPolyDataPiece'
    
    m_CreateGhostCells: bpy.props.BoolProperty(name='CreateGhostCells', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_CreateGhostCells','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKTransmitPolyDataPiece )        
TYPENAMES.append('VTKTransmitPolyDataPieceType' )

#--------------------------------------------------------------
class VTKTransmitRectilinearGridPiece(Node, BVTK_Node):

    bl_idname = 'VTKTransmitRectilinearGridPieceType'
    bl_label  = 'vtkTransmitRectilinearGridPiece'
    
    m_CreateGhostCells: bpy.props.BoolProperty(name='CreateGhostCells', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_CreateGhostCells','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKTransmitRectilinearGridPiece )        
TYPENAMES.append('VTKTransmitRectilinearGridPieceType' )

#--------------------------------------------------------------
class VTKTransmitStructuredDataPiece(Node, BVTK_Node):

    bl_idname = 'VTKTransmitStructuredDataPieceType'
    bl_label  = 'vtkTransmitStructuredDataPiece'
    
    m_CreateGhostCells: bpy.props.BoolProperty(name='CreateGhostCells', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_CreateGhostCells','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKTransmitStructuredDataPiece )        
TYPENAMES.append('VTKTransmitStructuredDataPieceType' )

#--------------------------------------------------------------
class VTKTransmitStructuredGridPiece(Node, BVTK_Node):

    bl_idname = 'VTKTransmitStructuredGridPieceType'
    bl_label  = 'vtkTransmitStructuredGridPiece'
    
    m_CreateGhostCells: bpy.props.BoolProperty(name='CreateGhostCells', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_CreateGhostCells','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKTransmitStructuredGridPiece )        
TYPENAMES.append('VTKTransmitStructuredGridPieceType' )

#--------------------------------------------------------------
class VTKTransmitUnstructuredGridPiece(Node, BVTK_Node):

    bl_idname = 'VTKTransmitUnstructuredGridPieceType'
    bl_label  = 'vtkTransmitUnstructuredGridPiece'
    
    m_CreateGhostCells: bpy.props.BoolProperty(name='CreateGhostCells', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_CreateGhostCells','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKTransmitUnstructuredGridPiece )        
TYPENAMES.append('VTKTransmitUnstructuredGridPieceType' )

#--------------------------------------------------------------
class VTKTransposeTable(Node, BVTK_Node):

    bl_idname = 'VTKTransposeTableType'
    bl_label  = 'vtkTransposeTable'
    
    m_AddIdColumn: bpy.props.BoolProperty(name='AddIdColumn', default=True, update=BVTK_Node.outdate_vtk_status)
    m_UseIdColumn: bpy.props.BoolProperty(name='UseIdColumn', default=False, update=BVTK_Node.outdate_vtk_status)
    m_IdColumnName: bpy.props.StringProperty(name='IdColumnName', default="ColName", update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=4, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_AddIdColumn','m_UseIdColumn','m_IdColumnName','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKTransposeTable )        
TYPENAMES.append('VTKTransposeTableType' )

#--------------------------------------------------------------
class VTKTreeAlgorithm(Node, BVTK_Node):

    bl_idname = 'VTKTreeAlgorithmType'
    bl_label  = 'vtkTreeAlgorithm'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKTreeAlgorithm )        
TYPENAMES.append('VTKTreeAlgorithmType' )

#--------------------------------------------------------------
class VTKTriangleFilter(Node, BVTK_Node):

    bl_idname = 'VTKTriangleFilterType'
    bl_label  = 'vtkTriangleFilter'
    
    m_PassLines: bpy.props.BoolProperty(name='PassLines', default=True, update=BVTK_Node.outdate_vtk_status)
    m_PassVerts: bpy.props.BoolProperty(name='PassVerts', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_Tolerance: bpy.props.FloatProperty(name='Tolerance', default=-1.0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=4, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_PassLines','m_PassVerts','m_ObjectName','m_Tolerance',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKTriangleFilter )        
TYPENAMES.append('VTKTriangleFilterType' )

#--------------------------------------------------------------
class VTKTriangleMeshPointNormals(Node, BVTK_Node):

    bl_idname = 'VTKTriangleMeshPointNormalsType'
    bl_label  = 'vtkTriangleMeshPointNormals'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKTriangleMeshPointNormals )        
TYPENAMES.append('VTKTriangleMeshPointNormalsType' )

#--------------------------------------------------------------
class VTKTriangularTCoords(Node, BVTK_Node):

    bl_idname = 'VTKTriangularTCoordsType'
    bl_label  = 'vtkTriangularTCoords'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKTriangularTCoords )        
TYPENAMES.append('VTKTriangularTCoordsType' )

#--------------------------------------------------------------
class VTKTubeBender(Node, BVTK_Node):

    bl_idname = 'VTKTubeBenderType'
    bl_label  = 'vtkTubeBender'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_Radius: bpy.props.FloatProperty(name='Radius', default=1.0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_Radius',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKTubeBender )        
TYPENAMES.append('VTKTubeBenderType' )

#--------------------------------------------------------------
class VTKTubeFilter(Node, BVTK_Node):

    bl_idname = 'VTKTubeFilterType'
    bl_label  = 'vtkTubeFilter'
    e_GenerateTCoords_items=[ (x,x,x) for x in ['Off', 'NormalizedLength', 'UseLength', 'UseScalars']]
    e_VaryRadius_items=[ (x,x,x) for x in ['VaryRadiusOff', 'VaryRadiusByScalar', 'VaryRadiusByVector', 'VaryRadiusByAbsoluteScalar', 'VaryRadiusByVectorNorm']]
    
    m_Capping: bpy.props.BoolProperty(name='Capping', default=True, update=BVTK_Node.outdate_vtk_status)
    m_SidesShareVertices: bpy.props.BoolProperty(name='SidesShareVertices', default=True, update=BVTK_Node.outdate_vtk_status)
    m_UseDefaultNormal: bpy.props.BoolProperty(name='UseDefaultNormal', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_NumberOfSides: bpy.props.IntProperty(name='NumberOfSides', default=3, update=BVTK_Node.outdate_vtk_status)
    m_Offset: bpy.props.IntProperty(name='Offset', default=0, update=BVTK_Node.outdate_vtk_status)
    m_OnRatio: bpy.props.IntProperty(name='OnRatio', default=1, update=BVTK_Node.outdate_vtk_status)
    m_Radius: bpy.props.FloatProperty(name='Radius', default=0.5, update=BVTK_Node.outdate_vtk_status)
    m_RadiusFactor: bpy.props.FloatProperty(name='RadiusFactor', default=10.0, update=BVTK_Node.outdate_vtk_status)
    m_TextureLength: bpy.props.FloatProperty(name='TextureLength', default=1.0, update=BVTK_Node.outdate_vtk_status)
    e_GenerateTCoords: bpy.props.EnumProperty(name='GenerateTCoords', default="Off", items=e_GenerateTCoords_items, update=BVTK_Node.outdate_vtk_status)
    e_VaryRadius: bpy.props.EnumProperty(name='VaryRadius', default="VaryRadiusOff", items=e_VaryRadius_items, update=BVTK_Node.outdate_vtk_status)
    m_DefaultNormal: bpy.props.FloatVectorProperty(name='DefaultNormal', default=[0.0, 0.0, 1.0], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=13, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_Capping','m_SidesShareVertices','m_UseDefaultNormal','m_ObjectName','m_NumberOfSides','m_Offset','m_OnRatio','m_Radius','m_RadiusFactor','m_TextureLength','e_GenerateTCoords','e_VaryRadius','m_DefaultNormal',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKTubeFilter )        
TYPENAMES.append('VTKTubeFilterType' )

#--------------------------------------------------------------
class VTKUncertaintyTubeFilter(Node, BVTK_Node):

    bl_idname = 'VTKUncertaintyTubeFilterType'
    bl_label  = 'vtkUncertaintyTubeFilter'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_NumberOfSides: bpy.props.IntProperty(name='NumberOfSides', default=12, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_NumberOfSides',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKUncertaintyTubeFilter )        
TYPENAMES.append('VTKUncertaintyTubeFilterType' )

#--------------------------------------------------------------
class VTKUndirectedGraphAlgorithm(Node, BVTK_Node):

    bl_idname = 'VTKUndirectedGraphAlgorithmType'
    bl_label  = 'vtkUndirectedGraphAlgorithm'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKUndirectedGraphAlgorithm )        
TYPENAMES.append('VTKUndirectedGraphAlgorithmType' )

#--------------------------------------------------------------
class VTKUniformGridAMRAlgorithm(Node, BVTK_Node):

    bl_idname = 'VTKUniformGridAMRAlgorithmType'
    bl_label  = 'vtkUniformGridAMRAlgorithm'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKUniformGridAMRAlgorithm )        
TYPENAMES.append('VTKUniformGridAMRAlgorithmType' )

#--------------------------------------------------------------
class VTKUniformGridGhostDataGenerator(Node, BVTK_Node):

    bl_idname = 'VTKUniformGridGhostDataGeneratorType'
    bl_label  = 'vtkUniformGridGhostDataGenerator'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_NumberOfGhostLayers: bpy.props.IntProperty(name='NumberOfGhostLayers', default=0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_NumberOfGhostLayers',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKUniformGridGhostDataGenerator )        
TYPENAMES.append('VTKUniformGridGhostDataGeneratorType' )

#--------------------------------------------------------------
class VTKUniformGridPartitioner(Node, BVTK_Node):

    bl_idname = 'VTKUniformGridPartitionerType'
    bl_label  = 'vtkUniformGridPartitioner'
    
    m_DuplicateNodes: bpy.props.BoolProperty(name='DuplicateNodes', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_NumberOfGhostLayers: bpy.props.IntProperty(name='NumberOfGhostLayers', default=0, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfPartitions: bpy.props.IntProperty(name='NumberOfPartitions', default=2, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=4, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_DuplicateNodes','m_ObjectName','m_NumberOfGhostLayers','m_NumberOfPartitions',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKUniformGridPartitioner )        
TYPENAMES.append('VTKUniformGridPartitionerType' )

#--------------------------------------------------------------
class VTKUnsignedDistance(Node, BVTK_Node):

    bl_idname = 'VTKUnsignedDistanceType'
    bl_label  = 'vtkUnsignedDistance'
    e_OutputScalarType_items=[ (x,x,x) for x in ['Float', 'Double']]
    
    m_AdjustBounds: bpy.props.BoolProperty(name='AdjustBounds', default=True, update=BVTK_Node.outdate_vtk_status)
    m_Capping: bpy.props.BoolProperty(name='Capping', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_AdjustDistance: bpy.props.FloatProperty(name='AdjustDistance', default=0.0125, update=BVTK_Node.outdate_vtk_status)
    m_CapValue: bpy.props.FloatProperty(name='CapValue', default=1e+30, update=BVTK_Node.outdate_vtk_status)
    m_Radius: bpy.props.FloatProperty(name='Radius', default=0.1, update=BVTK_Node.outdate_vtk_status)
    e_OutputScalarType: bpy.props.EnumProperty(name='OutputScalarType', default="Float", items=e_OutputScalarType_items, update=BVTK_Node.outdate_vtk_status)
    m_Dimensions: bpy.props.IntVectorProperty(name='Dimensions', default=[256, 256, 256], size=3, update=BVTK_Node.outdate_vtk_status)
    m_Bounds: bpy.props.FloatVectorProperty(name='Bounds', default=[0.0, 0.0, 0.0, 0.0, 0.0, 0.0], size=6, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=9, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_AdjustBounds','m_Capping','m_ObjectName','m_AdjustDistance','m_CapValue','m_Radius','e_OutputScalarType','m_Dimensions','m_Bounds',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKUnsignedDistance )        
TYPENAMES.append('VTKUnsignedDistanceType' )

#--------------------------------------------------------------
class VTKUnstructuredGridAlgorithm(Node, BVTK_Node):

    bl_idname = 'VTKUnstructuredGridAlgorithmType'
    bl_label  = 'vtkUnstructuredGridAlgorithm'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKUnstructuredGridAlgorithm )        
TYPENAMES.append('VTKUnstructuredGridAlgorithmType' )

#--------------------------------------------------------------
class VTKUnstructuredGridBaseAlgorithm(Node, BVTK_Node):

    bl_idname = 'VTKUnstructuredGridBaseAlgorithmType'
    bl_label  = 'vtkUnstructuredGridBaseAlgorithm'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKUnstructuredGridBaseAlgorithm )        
TYPENAMES.append('VTKUnstructuredGridBaseAlgorithmType' )

#--------------------------------------------------------------
class VTKUnstructuredGridGeometryFilter(Node, BVTK_Node):

    bl_idname = 'VTKUnstructuredGridGeometryFilterType'
    bl_label  = 'vtkUnstructuredGridGeometryFilter'
    
    m_CellClipping: bpy.props.BoolProperty(name='CellClipping', default=True, update=BVTK_Node.outdate_vtk_status)
    m_DuplicateGhostCellClipping: bpy.props.BoolProperty(name='DuplicateGhostCellClipping', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ExtentClipping: bpy.props.BoolProperty(name='ExtentClipping', default=True, update=BVTK_Node.outdate_vtk_status)
    m_Merging: bpy.props.BoolProperty(name='Merging', default=True, update=BVTK_Node.outdate_vtk_status)
    m_PassThroughCellIds: bpy.props.BoolProperty(name='PassThroughCellIds', default=True, update=BVTK_Node.outdate_vtk_status)
    m_PassThroughPointIds: bpy.props.BoolProperty(name='PassThroughPointIds', default=True, update=BVTK_Node.outdate_vtk_status)
    m_PointClipping: bpy.props.BoolProperty(name='PointClipping', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_OriginalCellIdsName: bpy.props.StringProperty(name='OriginalCellIdsName', default="vtkOriginalCellIds", update=BVTK_Node.outdate_vtk_status)
    m_OriginalPointIdsName: bpy.props.StringProperty(name='OriginalPointIdsName', default="vtkOriginalPointIds", update=BVTK_Node.outdate_vtk_status)
    m_CellMaximum: bpy.props.IntProperty(name='CellMaximum', default=1000000000, update=BVTK_Node.outdate_vtk_status)
    m_CellMinimum: bpy.props.IntProperty(name='CellMinimum', default=0, update=BVTK_Node.outdate_vtk_status)
    m_PointMaximum: bpy.props.IntProperty(name='PointMaximum', default=1000000000, update=BVTK_Node.outdate_vtk_status)
    m_PointMinimum: bpy.props.IntProperty(name='PointMinimum', default=0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=14, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_CellClipping','m_DuplicateGhostCellClipping','m_ExtentClipping','m_Merging','m_PassThroughCellIds','m_PassThroughPointIds','m_PointClipping','m_ObjectName','m_OriginalCellIdsName','m_OriginalPointIdsName','m_CellMaximum','m_CellMinimum','m_PointMaximum','m_PointMinimum',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKUnstructuredGridGeometryFilter )        
TYPENAMES.append('VTKUnstructuredGridGeometryFilterType' )

#--------------------------------------------------------------
class VTKUnstructuredGridGhostCellsGenerator(Node, BVTK_Node):

    bl_idname = 'VTKUnstructuredGridGhostCellsGeneratorType'
    bl_label  = 'vtkUnstructuredGridGhostCellsGenerator'
    
    m_BuildIfRequired: bpy.props.BoolProperty(name='BuildIfRequired', default=True, update=BVTK_Node.outdate_vtk_status)
    m_HasGlobalCellIds: bpy.props.BoolProperty(name='HasGlobalCellIds', default=False, update=BVTK_Node.outdate_vtk_status)
    m_UseGlobalPointIds: bpy.props.BoolProperty(name='UseGlobalPointIds', default=True, update=BVTK_Node.outdate_vtk_status)
    m_GlobalCellIdsArrayName: bpy.props.StringProperty(name='GlobalCellIdsArrayName', default="GlobalCellIds", update=BVTK_Node.outdate_vtk_status)
    m_GlobalPointIdsArrayName: bpy.props.StringProperty(name='GlobalPointIdsArrayName', default="GlobalNodeIds", update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_MinimumNumberOfGhostLevels: bpy.props.IntProperty(name='MinimumNumberOfGhostLevels', default=1, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=7, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_BuildIfRequired','m_HasGlobalCellIds','m_UseGlobalPointIds','m_GlobalCellIdsArrayName','m_GlobalPointIdsArrayName','m_ObjectName','m_MinimumNumberOfGhostLevels',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKUnstructuredGridGhostCellsGenerator )        
TYPENAMES.append('VTKUnstructuredGridGhostCellsGeneratorType' )

#--------------------------------------------------------------
class VTKUnstructuredGridQuadricDecimation(Node, BVTK_Node):

    bl_idname = 'VTKUnstructuredGridQuadricDecimationType'
    bl_label  = 'vtkUnstructuredGridQuadricDecimation'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_ScalarsName: bpy.props.StringProperty(name='ScalarsName', default="", update=BVTK_Node.outdate_vtk_status)
    m_AutoAddCandidates: bpy.props.IntProperty(name='AutoAddCandidates', default=1, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfCandidates: bpy.props.IntProperty(name='NumberOfCandidates', default=8, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfEdgesToDecimate: bpy.props.IntProperty(name='NumberOfEdgesToDecimate', default=0, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfTetsOutput: bpy.props.IntProperty(name='NumberOfTetsOutput', default=0, update=BVTK_Node.outdate_vtk_status)
    m_AutoAddCandidatesThreshold: bpy.props.FloatProperty(name='AutoAddCandidatesThreshold', default=0.4, update=BVTK_Node.outdate_vtk_status)
    m_BoundaryWeight: bpy.props.FloatProperty(name='BoundaryWeight', default=100.0, update=BVTK_Node.outdate_vtk_status)
    m_TargetReduction: bpy.props.FloatProperty(name='TargetReduction', default=1.0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=9, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_ScalarsName','m_AutoAddCandidates','m_NumberOfCandidates','m_NumberOfEdgesToDecimate','m_NumberOfTetsOutput','m_AutoAddCandidatesThreshold','m_BoundaryWeight','m_TargetReduction',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKUnstructuredGridQuadricDecimation )        
TYPENAMES.append('VTKUnstructuredGridQuadricDecimationType' )

#--------------------------------------------------------------
class VTKUnstructuredGridToExplicitStructuredGrid(Node, BVTK_Node):

    bl_idname = 'VTKUnstructuredGridToExplicitStructuredGridType'
    bl_label  = 'vtkUnstructuredGridToExplicitStructuredGrid'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKUnstructuredGridToExplicitStructuredGrid )        
TYPENAMES.append('VTKUnstructuredGridToExplicitStructuredGridType' )

#--------------------------------------------------------------
class VTKVectorDot(Node, BVTK_Node):

    bl_idname = 'VTKVectorDotType'
    bl_label  = 'vtkVectorDot'
    
    m_MapScalars: bpy.props.BoolProperty(name='MapScalars', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_ScalarRange: bpy.props.FloatVectorProperty(name='ScalarRange', default=[-1.0, 1.0], size=2, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=3, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_MapScalars','m_ObjectName','m_ScalarRange',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKVectorDot )        
TYPENAMES.append('VTKVectorDotType' )

#--------------------------------------------------------------
class VTKVectorNorm(Node, BVTK_Node):

    bl_idname = 'VTKVectorNormType'
    bl_label  = 'vtkVectorNorm'
    e_AttributeMode_items=[ (x,x,x) for x in ['Default', 'UsePointData', 'UseCellData']]
    
    m_Normalize: bpy.props.BoolProperty(name='Normalize', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    e_AttributeMode: bpy.props.EnumProperty(name='AttributeMode', default="Default", items=e_AttributeMode_items, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=3, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_Normalize','m_ObjectName','e_AttributeMode',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKVectorNorm )        
TYPENAMES.append('VTKVectorNormType' )

#--------------------------------------------------------------
class VTKVertexGlyphFilter(Node, BVTK_Node):

    bl_idname = 'VTKVertexGlyphFilterType'
    bl_label  = 'vtkVertexGlyphFilter'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKVertexGlyphFilter )        
TYPENAMES.append('VTKVertexGlyphFilterType' )

#--------------------------------------------------------------
class VTKVolumeOfRevolutionFilter(Node, BVTK_Node):

    bl_idname = 'VTKVolumeOfRevolutionFilterType'
    bl_label  = 'vtkVolumeOfRevolutionFilter'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_Resolution: bpy.props.IntProperty(name='Resolution', default=12, update=BVTK_Node.outdate_vtk_status)
    m_SweepAngle: bpy.props.FloatProperty(name='SweepAngle', default=360.0, update=BVTK_Node.outdate_vtk_status)
    m_AxisDirection: bpy.props.FloatVectorProperty(name='AxisDirection', default=[0.0, 0.0, 1.0], size=3, update=BVTK_Node.outdate_vtk_status)
    m_AxisPosition: bpy.props.FloatVectorProperty(name='AxisPosition', default=[0.0, 0.0, 0.0], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=5, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_Resolution','m_SweepAngle','m_AxisDirection','m_AxisPosition',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKVolumeOfRevolutionFilter )        
TYPENAMES.append('VTKVolumeOfRevolutionFilterType' )

#--------------------------------------------------------------
class VTKVolumeRayCastSpaceLeapingImageFilter(Node, BVTK_Node):

    bl_idname = 'VTKVolumeRayCastSpaceLeapingImageFilterType'
    bl_label  = 'vtkVolumeRayCastSpaceLeapingImageFilter'
    e_SplitMode_items=[ (x,x,x) for x in ['Slab', 'Beam', 'Block']]
    
    m_ComputeGradientOpacity: bpy.props.BoolProperty(name='ComputeGradientOpacity', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ComputeMinMax: bpy.props.BoolProperty(name='ComputeMinMax', default=True, update=BVTK_Node.outdate_vtk_status)
    m_EnableSMP: bpy.props.BoolProperty(name='EnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_GlobalDefaultEnableSMP: bpy.props.BoolProperty(name='GlobalDefaultEnableSMP', default=False, update=BVTK_Node.outdate_vtk_status)
    m_UpdateGradientOpacityFlags: bpy.props.BoolProperty(name='UpdateGradientOpacityFlags', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_DesiredBytesPerPiece: bpy.props.IntProperty(name='DesiredBytesPerPiece', default=65536, update=BVTK_Node.outdate_vtk_status)
    m_IndependentComponents: bpy.props.IntProperty(name='IndependentComponents', default=1, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfThreads: bpy.props.IntProperty(name='NumberOfThreads', default=4, update=BVTK_Node.outdate_vtk_status)
    e_SplitMode: bpy.props.EnumProperty(name='SplitMode', default="Slab", items=e_SplitMode_items, update=BVTK_Node.outdate_vtk_status)
    m_MinimumPieceSize: bpy.props.IntVectorProperty(name='MinimumPieceSize', default=[16, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    m_TableSize: bpy.props.IntVectorProperty(name='TableSize', default=[0, 0, 0, 0], size=4, update=BVTK_Node.outdate_vtk_status)
    m_TableScale: bpy.props.FloatVectorProperty(name='TableScale', default=[1.0, 1.0, 1.0, 1.0], size=4, update=BVTK_Node.outdate_vtk_status)
    m_TableShift: bpy.props.FloatVectorProperty(name='TableShift', default=[0.0, 0.0, 0.0, 0.0], size=4, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=14, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ComputeGradientOpacity','m_ComputeMinMax','m_EnableSMP','m_GlobalDefaultEnableSMP','m_UpdateGradientOpacityFlags','m_ObjectName','m_DesiredBytesPerPiece','m_IndependentComponents','m_NumberOfThreads','e_SplitMode','m_MinimumPieceSize','m_TableSize','m_TableScale','m_TableShift',]
    def m_connections( self ):
        return (['input'], ['output'], ['CurrentScalars'], []) 
    
add_class( VTKVolumeRayCastSpaceLeapingImageFilter )        
TYPENAMES.append('VTKVolumeRayCastSpaceLeapingImageFilterType' )

#--------------------------------------------------------------
class VTKVortexCore(Node, BVTK_Node):

    bl_idname = 'VTKVortexCoreType'
    bl_label  = 'vtkVortexCore'
    
    m_FasterApproximation: bpy.props.BoolProperty(name='FasterApproximation', default=False, update=BVTK_Node.outdate_vtk_status)
    m_HigherOrderMethod: bpy.props.BoolProperty(name='HigherOrderMethod', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=3, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_FasterApproximation','m_HigherOrderMethod','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKVortexCore )        
TYPENAMES.append('VTKVortexCoreType' )

#--------------------------------------------------------------
class VTKVoxelContoursToSurfaceFilter(Node, BVTK_Node):

    bl_idname = 'VTKVoxelContoursToSurfaceFilterType'
    bl_label  = 'vtkVoxelContoursToSurfaceFilter'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_MemoryLimitInBytes: bpy.props.IntProperty(name='MemoryLimitInBytes', default=10000000, update=BVTK_Node.outdate_vtk_status)
    m_Spacing: bpy.props.FloatVectorProperty(name='Spacing', default=[1.0, 1.0, 1.0], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=3, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_MemoryLimitInBytes','m_Spacing',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKVoxelContoursToSurfaceFilter )        
TYPENAMES.append('VTKVoxelContoursToSurfaceFilterType' )

#--------------------------------------------------------------
class VTKVoxelGrid(Node, BVTK_Node):

    bl_idname = 'VTKVoxelGridType'
    bl_label  = 'vtkVoxelGrid'
    e_ConfigurationStyle_items=[ (x,x,x) for x in ['Manual', 'LeafSize', 'Automatic']]
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_NumberOfPointsPerBin: bpy.props.IntProperty(name='NumberOfPointsPerBin', default=10, update=BVTK_Node.outdate_vtk_status)
    e_ConfigurationStyle: bpy.props.EnumProperty(name='ConfigurationStyle', default="Automatic", items=e_ConfigurationStyle_items, update=BVTK_Node.outdate_vtk_status)
    m_Divisions: bpy.props.IntVectorProperty(name='Divisions', default=[50, 50, 50], size=3, update=BVTK_Node.outdate_vtk_status)
    m_LeafSize: bpy.props.FloatVectorProperty(name='LeafSize', default=[1.0, 1.0, 1.0], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=5, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_NumberOfPointsPerBin','e_ConfigurationStyle','m_Divisions','m_LeafSize',]
    def m_connections( self ):
        return (['input'], ['output'], ['Kernel'], []) 
    
add_class( VTKVoxelGrid )        
TYPENAMES.append('VTKVoxelGridType' )

#--------------------------------------------------------------
class VTKVoxelModeller(Node, BVTK_Node):

    bl_idname = 'VTKVoxelModellerType'
    bl_label  = 'vtkVoxelModeller'
    e_ScalarType_items=[ (x,x,x) for x in ['Bit', 'Char', 'UnsignedChar', 'Short', 'UnsignedShort', 'Int', 'UnsignedInt', 'Long', 'UnsignedLong', 'Float', 'Double']]
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_BackgroundValue: bpy.props.FloatProperty(name='BackgroundValue', default=0.0, update=BVTK_Node.outdate_vtk_status)
    m_ForegroundValue: bpy.props.FloatProperty(name='ForegroundValue', default=1.0, update=BVTK_Node.outdate_vtk_status)
    m_MaximumDistance: bpy.props.FloatProperty(name='MaximumDistance', default=1.0, update=BVTK_Node.outdate_vtk_status)
    e_ScalarType: bpy.props.EnumProperty(name='ScalarType', default="Bit", items=e_ScalarType_items, update=BVTK_Node.outdate_vtk_status)
    m_SampleDimensions: bpy.props.IntVectorProperty(name='SampleDimensions', default=[50, 50, 50], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=6, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_BackgroundValue','m_ForegroundValue','m_MaximumDistance','e_ScalarType','m_SampleDimensions',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKVoxelModeller )        
TYPENAMES.append('VTKVoxelModellerType' )

#--------------------------------------------------------------
class VTKWarpLens(Node, BVTK_Node):

    bl_idname = 'VTKWarpLensType'
    bl_label  = 'vtkWarpLens'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_ImageHeight: bpy.props.IntProperty(name='ImageHeight', default=1, update=BVTK_Node.outdate_vtk_status)
    m_ImageWidth: bpy.props.IntProperty(name='ImageWidth', default=1, update=BVTK_Node.outdate_vtk_status)
    m_FormatHeight: bpy.props.FloatProperty(name='FormatHeight', default=1.0, update=BVTK_Node.outdate_vtk_status)
    m_FormatWidth: bpy.props.FloatProperty(name='FormatWidth', default=1.0, update=BVTK_Node.outdate_vtk_status)
    m_K1: bpy.props.FloatProperty(name='K1', default=-1e-06, update=BVTK_Node.outdate_vtk_status)
    m_K2: bpy.props.FloatProperty(name='K2', default=0.0, update=BVTK_Node.outdate_vtk_status)
    m_Kappa: bpy.props.FloatProperty(name='Kappa', default=-1e-06, update=BVTK_Node.outdate_vtk_status)
    m_P1: bpy.props.FloatProperty(name='P1', default=0.0, update=BVTK_Node.outdate_vtk_status)
    m_P2: bpy.props.FloatProperty(name='P2', default=0.0, update=BVTK_Node.outdate_vtk_status)
    m_Center: bpy.props.FloatVectorProperty(name='Center', default=[0.0, 0.0], size=2, update=BVTK_Node.outdate_vtk_status)
    m_PrincipalPoint: bpy.props.FloatVectorProperty(name='PrincipalPoint', default=[0.0, 0.0], size=2, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=12, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_ImageHeight','m_ImageWidth','m_FormatHeight','m_FormatWidth','m_K1','m_K2','m_Kappa','m_P1','m_P2','m_Center','m_PrincipalPoint',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKWarpLens )        
TYPENAMES.append('VTKWarpLensType' )

#--------------------------------------------------------------
class VTKWarpScalar(Node, BVTK_Node):

    bl_idname = 'VTKWarpScalarType'
    bl_label  = 'vtkWarpScalar'
    
    m_UseNormal: bpy.props.BoolProperty(name='UseNormal', default=True, update=BVTK_Node.outdate_vtk_status)
    m_XYPlane: bpy.props.BoolProperty(name='XYPlane', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_ScaleFactor: bpy.props.FloatProperty(name='ScaleFactor', default=1.0, update=BVTK_Node.outdate_vtk_status)
    m_Normal: bpy.props.FloatVectorProperty(name='Normal', default=[0.0, 0.0, 1.0], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=5, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_UseNormal','m_XYPlane','m_ObjectName','m_ScaleFactor','m_Normal',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKWarpScalar )        
TYPENAMES.append('VTKWarpScalarType' )

#--------------------------------------------------------------
class VTKWarpTo(Node, BVTK_Node):

    bl_idname = 'VTKWarpToType'
    bl_label  = 'vtkWarpTo'
    
    m_Absolute: bpy.props.BoolProperty(name='Absolute', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_ScaleFactor: bpy.props.FloatProperty(name='ScaleFactor', default=0.5, update=BVTK_Node.outdate_vtk_status)
    m_Position: bpy.props.FloatVectorProperty(name='Position', default=[0.0, 0.0, 0.0], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=4, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_Absolute','m_ObjectName','m_ScaleFactor','m_Position',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKWarpTo )        
TYPENAMES.append('VTKWarpToType' )

#--------------------------------------------------------------
class VTKWarpVector(Node, BVTK_Node):

    bl_idname = 'VTKWarpVectorType'
    bl_label  = 'vtkWarpVector'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_ScaleFactor: bpy.props.FloatProperty(name='ScaleFactor', default=1.0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_ScaleFactor',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKWarpVector )        
TYPENAMES.append('VTKWarpVectorType' )

#--------------------------------------------------------------
class VTKWeightedTransformFilter(Node, BVTK_Node):

    bl_idname = 'VTKWeightedTransformFilterType'
    bl_label  = 'vtkWeightedTransformFilter'
    
    m_AddInputValues: bpy.props.BoolProperty(name='AddInputValues', default=True, update=BVTK_Node.outdate_vtk_status)
    m_CellDataTransformIndexArray: bpy.props.StringProperty(name='CellDataTransformIndexArray', default="", update=BVTK_Node.outdate_vtk_status)
    m_CellDataWeightArray: bpy.props.StringProperty(name='CellDataWeightArray', default="", update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_TransformIndexArray: bpy.props.StringProperty(name='TransformIndexArray', default="", update=BVTK_Node.outdate_vtk_status)
    m_WeightArray: bpy.props.StringProperty(name='WeightArray', default="", update=BVTK_Node.outdate_vtk_status)
    m_NumberOfTransforms: bpy.props.IntProperty(name='NumberOfTransforms', default=0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=7, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_AddInputValues','m_CellDataTransformIndexArray','m_CellDataWeightArray','m_ObjectName','m_TransformIndexArray','m_WeightArray','m_NumberOfTransforms',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKWeightedTransformFilter )        
TYPENAMES.append('VTKWeightedTransformFilterType' )

#--------------------------------------------------------------
class VTKWindowedSincPolyDataFilter(Node, BVTK_Node):

    bl_idname = 'VTKWindowedSincPolyDataFilterType'
    bl_label  = 'vtkWindowedSincPolyDataFilter'
    
    m_BoundarySmoothing: bpy.props.BoolProperty(name='BoundarySmoothing', default=True, update=BVTK_Node.outdate_vtk_status)
    m_FeatureEdgeSmoothing: bpy.props.BoolProperty(name='FeatureEdgeSmoothing', default=True, update=BVTK_Node.outdate_vtk_status)
    m_GenerateErrorScalars: bpy.props.BoolProperty(name='GenerateErrorScalars', default=True, update=BVTK_Node.outdate_vtk_status)
    m_GenerateErrorVectors: bpy.props.BoolProperty(name='GenerateErrorVectors', default=True, update=BVTK_Node.outdate_vtk_status)
    m_NonManifoldSmoothing: bpy.props.BoolProperty(name='NonManifoldSmoothing', default=True, update=BVTK_Node.outdate_vtk_status)
    m_NormalizeCoordinates: bpy.props.BoolProperty(name='NormalizeCoordinates', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_NumberOfIterations: bpy.props.IntProperty(name='NumberOfIterations', default=20, update=BVTK_Node.outdate_vtk_status)
    m_EdgeAngle: bpy.props.FloatProperty(name='EdgeAngle', default=15.0, update=BVTK_Node.outdate_vtk_status)
    m_FeatureAngle: bpy.props.FloatProperty(name='FeatureAngle', default=45.0, update=BVTK_Node.outdate_vtk_status)
    m_PassBand: bpy.props.FloatProperty(name='PassBand', default=0.1, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=11, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_BoundarySmoothing','m_FeatureEdgeSmoothing','m_GenerateErrorScalars','m_GenerateErrorVectors','m_NonManifoldSmoothing','m_NormalizeCoordinates','m_ObjectName','m_NumberOfIterations','m_EdgeAngle','m_FeatureAngle','m_PassBand',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKWindowedSincPolyDataFilter )        
TYPENAMES.append('VTKWindowedSincPolyDataFilterType' )

#--------------------------------------------------------------
class VTKYoungsMaterialInterface(Node, BVTK_Node):

    bl_idname = 'VTKYoungsMaterialInterfaceType'
    bl_label  = 'vtkYoungsMaterialInterface'
    
    m_AxisSymetric: bpy.props.BoolProperty(name='AxisSymetric', default=True, update=BVTK_Node.outdate_vtk_status)
    m_FillMaterial: bpy.props.BoolProperty(name='FillMaterial', default=True, update=BVTK_Node.outdate_vtk_status)
    m_InverseNormal: bpy.props.BoolProperty(name='InverseNormal', default=True, update=BVTK_Node.outdate_vtk_status)
    m_OnionPeel: bpy.props.BoolProperty(name='OnionPeel', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ReverseMaterialOrder: bpy.props.BoolProperty(name='ReverseMaterialOrder', default=True, update=BVTK_Node.outdate_vtk_status)
    m_UseAllBlocks: bpy.props.BoolProperty(name='UseAllBlocks', default=True, update=BVTK_Node.outdate_vtk_status)
    m_UseFractionAsDistance: bpy.props.BoolProperty(name='UseFractionAsDistance', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_NumberOfMaterials: bpy.props.IntProperty(name='NumberOfMaterials', default=0, update=BVTK_Node.outdate_vtk_status)
    m_VolumeFractionRange: bpy.props.FloatVectorProperty(name='VolumeFractionRange', default=[0.01, 0.99], size=2, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=10, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_AxisSymetric','m_FillMaterial','m_InverseNormal','m_OnionPeel','m_ReverseMaterialOrder','m_UseAllBlocks','m_UseFractionAsDistance','m_ObjectName','m_NumberOfMaterials','m_VolumeFractionRange',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKYoungsMaterialInterface )        
TYPENAMES.append('VTKYoungsMaterialInterfaceType' )

#--------------------------------------------------------------
class VTKmAverageToCells(Node, BVTK_Node):

    bl_idname = 'VTKmAverageToCellsType'
    bl_label  = 'vtkmAverageToCells'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKmAverageToCells )        
TYPENAMES.append('VTKmAverageToCellsType' )

#--------------------------------------------------------------
class VTKmAverageToPoints(Node, BVTK_Node):

    bl_idname = 'VTKmAverageToPointsType'
    bl_label  = 'vtkmAverageToPoints'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKmAverageToPoints )        
TYPENAMES.append('VTKmAverageToPointsType' )

#--------------------------------------------------------------
class VTKmCleanGrid(Node, BVTK_Node):

    bl_idname = 'VTKmCleanGridType'
    bl_label  = 'vtkmCleanGrid'
    
    m_CompactPoints: bpy.props.BoolProperty(name='CompactPoints', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_CompactPoints','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKmCleanGrid )        
TYPENAMES.append('VTKmCleanGridType' )

#--------------------------------------------------------------
class VTKmClip(Node, BVTK_Node):

    bl_idname = 'VTKmClipType'
    bl_label  = 'vtkmClip'
    
    m_ComputeScalars: bpy.props.BoolProperty(name='ComputeScalars', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ForceVTKm: bpy.props.BoolProperty(name='ForceVTKm', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_ClipValue: bpy.props.FloatProperty(name='ClipValue', default=0.0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=4, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ComputeScalars','m_ForceVTKm','m_ObjectName','m_ClipValue',]
    def m_connections( self ):
        return (['input'], ['output'], ['ClipFunction'], []) 
    
add_class( VTKmClip )        
TYPENAMES.append('VTKmClipType' )

#--------------------------------------------------------------
class VTKmContour(Node, BVTK_Node):

    bl_idname = 'VTKmContourType'
    bl_label  = 'vtkmContour'
    
    m_ComputeGradients: bpy.props.BoolProperty(name='ComputeGradients', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ComputeNormals: bpy.props.BoolProperty(name='ComputeNormals', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ComputeScalars: bpy.props.BoolProperty(name='ComputeScalars', default=True, update=BVTK_Node.outdate_vtk_status)
    m_GenerateTriangles: bpy.props.BoolProperty(name='GenerateTriangles', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_ArrayComponent: bpy.props.IntProperty(name='ArrayComponent', default=0, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfContours: bpy.props.IntProperty(name='NumberOfContours', default=1, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=7, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ComputeGradients','m_ComputeNormals','m_ComputeScalars','m_GenerateTriangles','m_ObjectName','m_ArrayComponent','m_NumberOfContours',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKmContour )        
TYPENAMES.append('VTKmContourType' )

#--------------------------------------------------------------
class VTKmCoordinateSystemTransform(Node, BVTK_Node):

    bl_idname = 'VTKmCoordinateSystemTransformType'
    bl_label  = 'vtkmCoordinateSystemTransform'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKmCoordinateSystemTransform )        
TYPENAMES.append('VTKmCoordinateSystemTransformType' )

#--------------------------------------------------------------
class VTKmExternalFaces(Node, BVTK_Node):

    bl_idname = 'VTKmExternalFacesType'
    bl_label  = 'vtkmExternalFaces'
    
    m_CompactPoints: bpy.props.BoolProperty(name='CompactPoints', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_CompactPoints','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKmExternalFaces )        
TYPENAMES.append('VTKmExternalFacesType' )

#--------------------------------------------------------------
class VTKmExtractVOI(Node, BVTK_Node):

    bl_idname = 'VTKmExtractVOIType'
    bl_label  = 'vtkmExtractVOI'
    
    m_ForceVTKm: bpy.props.BoolProperty(name='ForceVTKm', default=True, update=BVTK_Node.outdate_vtk_status)
    m_IncludeBoundary: bpy.props.BoolProperty(name='IncludeBoundary', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_SampleRate: bpy.props.IntVectorProperty(name='SampleRate', default=[1, 1, 1], size=3, update=BVTK_Node.outdate_vtk_status)
    m_VOI: bpy.props.IntVectorProperty(name='VOI', default=[0, 1000000000, 0, 1000000000, 0, 1000000000], size=6, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=5, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ForceVTKm','m_IncludeBoundary','m_ObjectName','m_SampleRate','m_VOI',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKmExtractVOI )        
TYPENAMES.append('VTKmExtractVOIType' )

#--------------------------------------------------------------
class VTKmGradient(Node, BVTK_Node):

    bl_idname = 'VTKmGradientType'
    bl_label  = 'vtkmGradient'
    
    m_ComputeDivergence: bpy.props.BoolProperty(name='ComputeDivergence', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ComputeGradient: bpy.props.BoolProperty(name='ComputeGradient', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ComputeQCriterion: bpy.props.BoolProperty(name='ComputeQCriterion', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ComputeVorticity: bpy.props.BoolProperty(name='ComputeVorticity', default=True, update=BVTK_Node.outdate_vtk_status)
    m_FasterApproximation: bpy.props.BoolProperty(name='FasterApproximation', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ForceVTKm: bpy.props.BoolProperty(name='ForceVTKm', default=True, update=BVTK_Node.outdate_vtk_status)
    m_DivergenceArrayName: bpy.props.StringProperty(name='DivergenceArrayName', default="", update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_QCriterionArrayName: bpy.props.StringProperty(name='QCriterionArrayName', default="", update=BVTK_Node.outdate_vtk_status)
    m_ResultArrayName: bpy.props.StringProperty(name='ResultArrayName', default="", update=BVTK_Node.outdate_vtk_status)
    m_VorticityArrayName: bpy.props.StringProperty(name='VorticityArrayName', default="", update=BVTK_Node.outdate_vtk_status)
    m_ContributingCellOption: bpy.props.IntProperty(name='ContributingCellOption', default=0, update=BVTK_Node.outdate_vtk_status)
    m_ReplacementValueOption: bpy.props.IntProperty(name='ReplacementValueOption', default=0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=13, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ComputeDivergence','m_ComputeGradient','m_ComputeQCriterion','m_ComputeVorticity','m_FasterApproximation','m_ForceVTKm','m_DivergenceArrayName','m_ObjectName','m_QCriterionArrayName','m_ResultArrayName','m_VorticityArrayName','m_ContributingCellOption','m_ReplacementValueOption',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKmGradient )        
TYPENAMES.append('VTKmGradientType' )

#--------------------------------------------------------------
class VTKmHistogram(Node, BVTK_Node):

    bl_idname = 'VTKmHistogramType'
    bl_label  = 'vtkmHistogram'
    
    m_CenterBinsAroundMinAndMax: bpy.props.BoolProperty(name='CenterBinsAroundMinAndMax', default=False, update=BVTK_Node.outdate_vtk_status)
    m_UseCustomBinRanges: bpy.props.BoolProperty(name='UseCustomBinRanges', default=False, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_NumberOfBins: bpy.props.IntProperty(name='NumberOfBins', default=10, update=BVTK_Node.outdate_vtk_status)
    m_CustomBinRange: bpy.props.FloatVectorProperty(name='CustomBinRange', default=[100.0, 2.1219957915e-314], size=2, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=5, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_CenterBinsAroundMinAndMax','m_UseCustomBinRanges','m_ObjectName','m_NumberOfBins','m_CustomBinRange',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKmHistogram )        
TYPENAMES.append('VTKmHistogramType' )

#--------------------------------------------------------------
class VTKmImageConnectivity(Node, BVTK_Node):

    bl_idname = 'VTKmImageConnectivityType'
    bl_label  = 'vtkmImageConnectivity'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKmImageConnectivity )        
TYPENAMES.append('VTKmImageConnectivityType' )

#--------------------------------------------------------------
class VTKmLevelOfDetail(Node, BVTK_Node):

    bl_idname = 'VTKmLevelOfDetailType'
    bl_label  = 'vtkmLevelOfDetail'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_NumberOfXDivisions: bpy.props.IntProperty(name='NumberOfXDivisions', default=512, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfYDivisions: bpy.props.IntProperty(name='NumberOfYDivisions', default=512, update=BVTK_Node.outdate_vtk_status)
    m_NumberOfZDivisions: bpy.props.IntProperty(name='NumberOfZDivisions', default=512, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=4, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_NumberOfXDivisions','m_NumberOfYDivisions','m_NumberOfZDivisions',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKmLevelOfDetail )        
TYPENAMES.append('VTKmLevelOfDetailType' )

#--------------------------------------------------------------
class VTKmNDHistogram(Node, BVTK_Node):

    bl_idname = 'VTKmNDHistogramType'
    bl_label  = 'vtkmNDHistogram'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKmNDHistogram )        
TYPENAMES.append('VTKmNDHistogramType' )

#--------------------------------------------------------------
class VTKmPointElevation(Node, BVTK_Node):

    bl_idname = 'VTKmPointElevationType'
    bl_label  = 'vtkmPointElevation'
    
    m_ForceVTKm: bpy.props.BoolProperty(name='ForceVTKm', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_HighPoint: bpy.props.FloatVectorProperty(name='HighPoint', default=[0.0, 0.0, 1.0], size=3, update=BVTK_Node.outdate_vtk_status)
    m_LowPoint: bpy.props.FloatVectorProperty(name='LowPoint', default=[0.0, 0.0, 0.0], size=3, update=BVTK_Node.outdate_vtk_status)
    m_ScalarRange: bpy.props.FloatVectorProperty(name='ScalarRange', default=[0.0, 1.0], size=2, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=5, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ForceVTKm','m_ObjectName','m_HighPoint','m_LowPoint','m_ScalarRange',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKmPointElevation )        
TYPENAMES.append('VTKmPointElevationType' )

#--------------------------------------------------------------
class VTKmPointTransform(Node, BVTK_Node):

    bl_idname = 'VTKmPointTransformType'
    bl_label  = 'vtkmPointTransform'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=1, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], ['Transform'], []) 
    
add_class( VTKmPointTransform )        
TYPENAMES.append('VTKmPointTransformType' )

#--------------------------------------------------------------
class VTKmPolyDataNormals(Node, BVTK_Node):

    bl_idname = 'VTKmPolyDataNormalsType'
    bl_label  = 'vtkmPolyDataNormals'
    
    m_AutoOrientNormals: bpy.props.BoolProperty(name='AutoOrientNormals', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ComputeCellNormals: bpy.props.BoolProperty(name='ComputeCellNormals', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ComputePointNormals: bpy.props.BoolProperty(name='ComputePointNormals', default=True, update=BVTK_Node.outdate_vtk_status)
    m_Consistency: bpy.props.BoolProperty(name='Consistency', default=True, update=BVTK_Node.outdate_vtk_status)
    m_FlipNormals: bpy.props.BoolProperty(name='FlipNormals', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ForceVTKm: bpy.props.BoolProperty(name='ForceVTKm', default=True, update=BVTK_Node.outdate_vtk_status)
    m_NonManifoldTraversal: bpy.props.BoolProperty(name='NonManifoldTraversal', default=True, update=BVTK_Node.outdate_vtk_status)
    m_Splitting: bpy.props.BoolProperty(name='Splitting', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_FeatureAngle: bpy.props.FloatProperty(name='FeatureAngle', default=30.0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=10, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_AutoOrientNormals','m_ComputeCellNormals','m_ComputePointNormals','m_Consistency','m_FlipNormals','m_ForceVTKm','m_NonManifoldTraversal','m_Splitting','m_ObjectName','m_FeatureAngle',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKmPolyDataNormals )        
TYPENAMES.append('VTKmPolyDataNormalsType' )

#--------------------------------------------------------------
class VTKmThreshold(Node, BVTK_Node):

    bl_idname = 'VTKmThresholdType'
    bl_label  = 'vtkmThreshold'
    e_AttributeMode_items=[ (x,x,x) for x in ['Default', 'UsePointData', 'UseCellData']]
    e_ComponentMode_items=[ (x,x,x) for x in ['UseSelected', 'UseAll', 'UseAny']]
    e_PointsDataType_items=[ (x,x,x) for x in ['Float', 'Double']]
    
    m_AllScalars: bpy.props.BoolProperty(name='AllScalars', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ForceVTKm: bpy.props.BoolProperty(name='ForceVTKm', default=True, update=BVTK_Node.outdate_vtk_status)
    m_Invert: bpy.props.BoolProperty(name='Invert', default=False, update=BVTK_Node.outdate_vtk_status)
    m_UseContinuousCellRange: bpy.props.BoolProperty(name='UseContinuousCellRange', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_SelectedComponent: bpy.props.IntProperty(name='SelectedComponent', default=0, update=BVTK_Node.outdate_vtk_status)
    m_ThresholdFunction: bpy.props.IntProperty(name='ThresholdFunction', default=0, update=BVTK_Node.outdate_vtk_status)
    m_LowerThreshold: bpy.props.FloatProperty(name='LowerThreshold', default=-1e+30, update=BVTK_Node.outdate_vtk_status)
    m_UpperThreshold: bpy.props.FloatProperty(name='UpperThreshold', default=1e+30, update=BVTK_Node.outdate_vtk_status)
    e_AttributeMode: bpy.props.EnumProperty(name='AttributeMode', default="Default", items=e_AttributeMode_items, update=BVTK_Node.outdate_vtk_status)
    e_ComponentMode: bpy.props.EnumProperty(name='ComponentMode', default="UseSelected", items=e_ComponentMode_items, update=BVTK_Node.outdate_vtk_status)
    e_PointsDataType: bpy.props.EnumProperty(name='PointsDataType', default="Double", items=e_PointsDataType_items, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=12, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_AllScalars','m_ForceVTKm','m_Invert','m_UseContinuousCellRange','m_ObjectName','m_SelectedComponent','m_ThresholdFunction','m_LowerThreshold','m_UpperThreshold','e_AttributeMode','e_ComponentMode','e_PointsDataType',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKmThreshold )        
TYPENAMES.append('VTKmThresholdType' )

#--------------------------------------------------------------
class VTKmTriangleMeshPointNormals(Node, BVTK_Node):

    bl_idname = 'VTKmTriangleMeshPointNormalsType'
    bl_label  = 'vtkmTriangleMeshPointNormals'
    
    m_ForceVTKm: bpy.props.BoolProperty(name='ForceVTKm', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ForceVTKm','m_ObjectName',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKmTriangleMeshPointNormals )        
TYPENAMES.append('VTKmTriangleMeshPointNormalsType' )

#--------------------------------------------------------------
class VTKmWarpScalar(Node, BVTK_Node):

    bl_idname = 'VTKmWarpScalarType'
    bl_label  = 'vtkmWarpScalar'
    
    m_UseNormal: bpy.props.BoolProperty(name='UseNormal', default=True, update=BVTK_Node.outdate_vtk_status)
    m_XYPlane: bpy.props.BoolProperty(name='XYPlane', default=True, update=BVTK_Node.outdate_vtk_status)
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_ScaleFactor: bpy.props.FloatProperty(name='ScaleFactor', default=1.0, update=BVTK_Node.outdate_vtk_status)
    m_Normal: bpy.props.FloatVectorProperty(name='Normal', default=[0.0, 0.0, 1.0], size=3, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=5, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_UseNormal','m_XYPlane','m_ObjectName','m_ScaleFactor','m_Normal',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKmWarpScalar )        
TYPENAMES.append('VTKmWarpScalarType' )

#--------------------------------------------------------------
class VTKmWarpVector(Node, BVTK_Node):

    bl_idname = 'VTKmWarpVectorType'
    bl_label  = 'vtkmWarpVector'
    
    m_ObjectName: bpy.props.StringProperty(name='ObjectName', default="", update=BVTK_Node.outdate_vtk_status)
    m_ScaleFactor: bpy.props.FloatProperty(name='ScaleFactor', default=1.0, update=BVTK_Node.outdate_vtk_status)
    
    b_properties: bpy.props.BoolVectorProperty(name="", size=2, get=BVTK_Node.get_b, set=BVTK_Node.set_b)

    def m_properties( self ):
        return ['m_ObjectName','m_ScaleFactor',]
    def m_connections( self ):
        return (['input'], ['output'], [], []) 
    
add_class( VTKmWarpVector )        
TYPENAMES.append('VTKmWarpVectorType' )

#--------------------------------------------------------------
menu_items = [ NodeItem(x) for x in TYPENAMES ]
CATEGORIES.append( BVTK_NodeCategory( 'Filter1', 'Filter1', items=menu_items) )